]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/mac/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
reSWIGged
[wxWidgets.git] / wxPython / src / mac / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_buffer swig_types[0]
2467 #define SWIGTYPE_p_char swig_types[1]
2468 #define SWIGTYPE_p_form_ops_t swig_types[2]
2469 #define SWIGTYPE_p_int swig_types[3]
2470 #define SWIGTYPE_p_long swig_types[4]
2471 #define SWIGTYPE_p_unsigned_char swig_types[5]
2472 #define SWIGTYPE_p_unsigned_int swig_types[6]
2473 #define SWIGTYPE_p_unsigned_long swig_types[7]
2474 #define SWIGTYPE_p_wxANIHandler swig_types[8]
2475 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
2476 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
2477 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
2478 #define SWIGTYPE_p_wxAppTraits swig_types[12]
2479 #define SWIGTYPE_p_wxArrayString swig_types[13]
2480 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2481 #define SWIGTYPE_p_wxBitmap swig_types[15]
2482 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
2483 #define SWIGTYPE_p_wxButton swig_types[17]
2484 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2485 #define SWIGTYPE_p_wxCaret swig_types[19]
2486 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2487 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[21]
2488 #define SWIGTYPE_p_wxCloseEvent swig_types[22]
2489 #define SWIGTYPE_p_wxColour swig_types[23]
2490 #define SWIGTYPE_p_wxCommandEvent swig_types[24]
2491 #define SWIGTYPE_p_wxContextMenuEvent swig_types[25]
2492 #define SWIGTYPE_p_wxControl swig_types[26]
2493 #define SWIGTYPE_p_wxControlWithItems swig_types[27]
2494 #define SWIGTYPE_p_wxCursor swig_types[28]
2495 #define SWIGTYPE_p_wxDC swig_types[29]
2496 #define SWIGTYPE_p_wxDateEvent swig_types[30]
2497 #define SWIGTYPE_p_wxDateTime swig_types[31]
2498 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[32]
2499 #define SWIGTYPE_p_wxDouble swig_types[33]
2500 #define SWIGTYPE_p_wxDropFilesEvent swig_types[34]
2501 #define SWIGTYPE_p_wxDuplexMode swig_types[35]
2502 #define SWIGTYPE_p_wxEraseEvent swig_types[36]
2503 #define SWIGTYPE_p_wxEvent swig_types[37]
2504 #define SWIGTYPE_p_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_wxSizerFlags swig_types[120]
2587 #define SWIGTYPE_p_wxSizerItem swig_types[121]
2588 #define SWIGTYPE_p_wxStaticBox swig_types[122]
2589 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[123]
2590 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[124]
2591 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[125]
2592 #define SWIGTYPE_p_wxTGAHandler swig_types[126]
2593 #define SWIGTYPE_p_wxTIFFHandler swig_types[127]
2594 #define SWIGTYPE_p_wxToolTip swig_types[128]
2595 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[129]
2596 #define SWIGTYPE_p_wxValidator swig_types[130]
2597 #define SWIGTYPE_p_wxVisualAttributes swig_types[131]
2598 #define SWIGTYPE_p_wxWindow swig_types[132]
2599 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[133]
2600 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[134]
2601 #define SWIGTYPE_p_wxXPMHandler swig_types[135]
2602 #define SWIGTYPE_p_wxZipFSHandler swig_types[136]
2603 static swig_type_info *swig_types[138];
2604 static swig_module_info swig_module = {swig_types, 137, 0, 0, 0, 0};
2605 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2606 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2607
2608 /* -------- TYPES TABLE (END) -------- */
2609
2610 #if (PY_VERSION_HEX <= 0x02000000)
2611 # if !defined(SWIG_PYTHON_CLASSIC)
2612 # error "This python version requires to use swig with the '-classic' option"
2613 # endif
2614 #endif
2615 #if (PY_VERSION_HEX <= 0x02020000)
2616 # error "This python version requires to use swig with the '-nomodern' option"
2617 #endif
2618 #if (PY_VERSION_HEX <= 0x02020000)
2619 # error "This python version requires to use swig with the '-nomodernargs' option"
2620 #endif
2621 #ifndef METH_O
2622 # error "This python version requires to use swig with the '-nofastunpack' option"
2623 #endif
2624
2625 /*-----------------------------------------------
2626 @(target):= _core_.so
2627 ------------------------------------------------*/
2628 #define SWIG_init init_core_
2629
2630 #define SWIG_name "_core_"
2631
2632 #define SWIGVERSION 0x010329
2633
2634
2635 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2636 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2637
2638
2639 #include <stdexcept>
2640
2641
2642 namespace swig {
2643 class PyObject_ptr {
2644 protected:
2645 PyObject *_obj;
2646
2647 public:
2648 PyObject_ptr() :_obj(0)
2649 {
2650 }
2651
2652 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2653 {
2654 Py_XINCREF(_obj);
2655 }
2656
2657 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2658 {
2659 if (initial_ref) Py_XINCREF(_obj);
2660 }
2661
2662 PyObject_ptr & operator=(const PyObject_ptr& item)
2663 {
2664 Py_XINCREF(item._obj);
2665 Py_XDECREF(_obj);
2666 _obj = item._obj;
2667 return *this;
2668 }
2669
2670 ~PyObject_ptr()
2671 {
2672 Py_XDECREF(_obj);
2673 }
2674
2675 operator PyObject *() const
2676 {
2677 return _obj;
2678 }
2679
2680 PyObject *operator->() const
2681 {
2682 return _obj;
2683 }
2684 };
2685 }
2686
2687
2688 namespace swig {
2689 struct PyObject_var : PyObject_ptr {
2690 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2691
2692 PyObject_var & operator = (PyObject* obj)
2693 {
2694 Py_XDECREF(_obj);
2695 _obj = obj;
2696 return *this;
2697 }
2698 };
2699 }
2700
2701
2702 #include "wx/wxPython/wxPython_int.h"
2703 #include "wx/wxPython/pyclasses.h"
2704 #include "wx/wxPython/twoitem.h"
2705
2706
2707 #ifndef wxPyUSE_EXPORT
2708 // Helper functions for dealing with SWIG objects and such. These are
2709 // located here so they know about the SWIG types and functions declared
2710 // in the wrapper code.
2711
2712 #include <wx/hashmap.h>
2713 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2714
2715
2716 // Maintains a hashmap of className to swig_type_info pointers. Given the
2717 // name of a class either looks up the type info in the cache, or scans the
2718 // SWIG tables for it.
2719 extern PyObject* wxPyPtrTypeMap;
2720 static
2721 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2722
2723 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2724
2725 if (typeInfoCache == NULL)
2726 typeInfoCache = new wxPyTypeInfoHashMap;
2727
2728 wxString name(className);
2729 swig_type_info* swigType = (*typeInfoCache)[name];
2730
2731 if (! swigType) {
2732 // it wasn't in the cache, so look it up from SWIG
2733 name.Append(wxT(" *"));
2734 swigType = SWIG_TypeQuery(name.mb_str());
2735
2736 // if it still wasn't found, try looking for a mapped name
2737 if (!swigType) {
2738 PyObject* item;
2739 name = className;
2740
2741 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2742 (char*)(const char*)name.mbc_str())) != NULL) {
2743 name = wxString(PyString_AsString(item), *wxConvCurrent);
2744 name.Append(wxT(" *"));
2745 swigType = SWIG_TypeQuery(name.mb_str());
2746 }
2747 }
2748 if (swigType) {
2749 // and add it to the map if found
2750 (*typeInfoCache)[className] = swigType;
2751 }
2752 }
2753 return swigType;
2754 }
2755
2756
2757 // Check if a class name is a type known to SWIG
2758 bool wxPyCheckSwigType(const wxChar* className) {
2759
2760 swig_type_info* swigType = wxPyFindSwigType(className);
2761 return swigType != NULL;
2762 }
2763
2764
2765 // Given a pointer to a C++ object and a class name, construct a Python proxy
2766 // object for it.
2767 PyObject* wxPyConstructObject(void* ptr,
2768 const wxChar* className,
2769 int setThisOwn) {
2770
2771 swig_type_info* swigType = wxPyFindSwigType(className);
2772 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2773
2774 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2775 }
2776
2777
2778 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2779 // Ensures that the proxy object is of the specified (or derived) type. If
2780 // not able to perform the conversion then a Python exception is set and the
2781 // error should be handled properly in the caller. Returns True on success.
2782 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2783 const wxChar* className) {
2784
2785 swig_type_info* swigType = wxPyFindSwigType(className);
2786 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2787
2788 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2789 }
2790
2791
2792
2793 // Make a SWIGified pointer object suitable for a .this attribute
2794 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2795
2796 PyObject* robj = NULL;
2797
2798 swig_type_info* swigType = wxPyFindSwigType(className);
2799 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2800
2801 robj = PySwigObject_New(ptr, swigType, 0);
2802 return robj;
2803 }
2804
2805
2806 // Python's PyInstance_Check does not return True for instances of new-style
2807 // classes. This should get close enough for both new and old classes but I
2808 // should re-evaluate the need for doing instance checks...
2809 bool wxPyInstance_Check(PyObject* obj) {
2810 return PyObject_HasAttrString(obj, "__class__") != 0;
2811 }
2812
2813
2814 // This one checks if the object is an instance of a SWIG proxy class (it has
2815 // a .this attribute, and the .this attribute is a PySwigObject.)
2816 bool wxPySwigInstance_Check(PyObject* obj) {
2817 static PyObject* this_str = NULL;
2818 if (this_str == NULL)
2819 this_str = PyString_FromString("this");
2820
2821 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2822 if (this_attr) {
2823 bool retval = (PySwigObject_Check(this_attr) != 0);
2824 Py_DECREF(this_attr);
2825 return retval;
2826 }
2827
2828 PyErr_Clear();
2829 return false;
2830 }
2831
2832
2833 // Export a C API in a struct. Other modules will be able to load this from
2834 // the wx._core_ module and will then have safe access to these functions,
2835 // even if they are located in another shared library.
2836 static wxPyCoreAPI API = {
2837
2838 wxPyCheckSwigType,
2839 wxPyConstructObject,
2840 wxPyConvertSwigPtr,
2841 wxPyMakeSwigPtr,
2842
2843 wxPyBeginAllowThreads,
2844 wxPyEndAllowThreads,
2845 wxPyBeginBlockThreads,
2846 wxPyEndBlockThreads,
2847
2848 wxPy_ConvertList,
2849
2850 wxString_in_helper,
2851 Py2wxString,
2852 wx2PyString,
2853
2854 byte_LIST_helper,
2855 int_LIST_helper,
2856 long_LIST_helper,
2857 string_LIST_helper,
2858 wxPoint_LIST_helper,
2859 wxBitmap_LIST_helper,
2860 wxString_LIST_helper,
2861 wxAcceleratorEntry_LIST_helper,
2862
2863 wxSize_helper,
2864 wxPoint_helper,
2865 wxRealPoint_helper,
2866 wxRect_helper,
2867 wxColour_helper,
2868 wxPoint2D_helper,
2869
2870 wxPySimple_typecheck,
2871 wxColour_typecheck,
2872
2873 wxPyCBH_setCallbackInfo,
2874 wxPyCBH_findCallback,
2875 wxPyCBH_callCallback,
2876 wxPyCBH_callCallbackObj,
2877 wxPyCBH_delete,
2878
2879 wxPyMake_wxObject,
2880 wxPyMake_wxSizer,
2881 wxPyPtrTypeMap_Add,
2882 wxPy2int_seq_helper,
2883 wxPy4int_seq_helper,
2884 wxArrayString2PyList_helper,
2885 wxArrayInt2PyList_helper,
2886
2887 wxPyClientData_dtor,
2888 wxPyUserData_dtor,
2889 wxPyOORClientData_dtor,
2890
2891 wxPyCBInputStream_create,
2892 wxPyCBInputStream_copy,
2893
2894 wxPyInstance_Check,
2895 wxPySwigInstance_Check,
2896
2897 wxPyCheckForApp,
2898
2899 wxArrayDouble2PyList_helper,
2900 wxPoint2D_LIST_helper,
2901 wxRect2D_helper,
2902
2903 };
2904
2905 #endif
2906
2907
2908 #if !WXWIN_COMPATIBILITY_2_4
2909 #define wxHIDE_READONLY 0
2910 #endif
2911
2912
2913 #define SWIG_From_long PyInt_FromLong
2914
2915
2916 SWIGINTERNINLINE PyObject *
2917 SWIG_From_int (int value)
2918 {
2919 return SWIG_From_long (value);
2920 }
2921
2922 static const wxString wxPyEmptyString(wxEmptyString);
2923 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2924 return self->GetClassInfo()->GetClassName();
2925 }
2926 SWIGINTERN void wxObject_Destroy(wxObject *self){
2927 delete self;
2928 }
2929
2930 #ifndef __WXMAC__
2931 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2932 #endif
2933
2934
2935 #include <limits.h>
2936 #ifndef LLONG_MIN
2937 # define LLONG_MIN LONG_LONG_MIN
2938 #endif
2939 #ifndef LLONG_MAX
2940 # define LLONG_MAX LONG_LONG_MAX
2941 #endif
2942 #ifndef ULLONG_MAX
2943 # define ULLONG_MAX ULONG_LONG_MAX
2944 #endif
2945
2946
2947 SWIGINTERN int
2948 SWIG_AsVal_long (PyObject* obj, long* val)
2949 {
2950 if (PyNumber_Check(obj)) {
2951 if (val) *val = PyInt_AsLong(obj);
2952 return SWIG_OK;
2953 }
2954 return SWIG_TypeError;
2955 }
2956
2957
2958 SWIGINTERN int
2959 SWIG_AsVal_int (PyObject * obj, int *val)
2960 {
2961 long v;
2962 int res = SWIG_AsVal_long (obj, &v);
2963 if (SWIG_IsOK(res)) {
2964 if ((v < INT_MIN || v > INT_MAX)) {
2965 return SWIG_OverflowError;
2966 } else {
2967 if (val) *val = static_cast< int >(v);
2968 }
2969 }
2970 return res;
2971 }
2972
2973 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2974 wxSize temp, *obj = &temp;
2975 if ( other == Py_None ) return false;
2976 if ( ! wxSize_helper(other, &obj) ) {
2977 PyErr_Clear();
2978 return false;
2979 }
2980 return self->operator==(*obj);
2981 }
2982 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2983 wxSize temp, *obj = &temp;
2984 if ( other == Py_None ) return true;
2985 if ( ! wxSize_helper(other, &obj)) {
2986 PyErr_Clear();
2987 return true;
2988 }
2989 return self->operator!=(*obj);
2990 }
2991
2992 #include <float.h>
2993
2994
2995 SWIGINTERN int
2996 SWIG_AsVal_double (PyObject *obj, double* val)
2997 {
2998 if (PyNumber_Check(obj)) {
2999 if (val) *val = PyFloat_AsDouble(obj);
3000 return SWIG_OK;
3001 }
3002 return SWIG_TypeError;
3003 }
3004
3005
3006 SWIGINTERN int
3007 SWIG_AsVal_float (PyObject * obj, float *val)
3008 {
3009 double v;
3010 int res = SWIG_AsVal_double (obj, &v);
3011 if (SWIG_IsOK(res)) {
3012 if ((v < -FLT_MAX || v > FLT_MAX)) {
3013 return SWIG_OverflowError;
3014 } else {
3015 if (val) *val = static_cast< float >(v);
3016 }
3017 }
3018 return res;
3019 }
3020
3021 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
3022 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3023 PyObject* tup = PyTuple_New(2);
3024 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3025 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3026 //wxPyEndBlockThreads(blocked);
3027 return tup;
3028 }
3029
3030 #define SWIG_From_double PyFloat_FromDouble
3031
3032 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3033 wxRealPoint temp, *obj = &temp;
3034 if ( other == Py_None ) return false;
3035 if ( ! wxRealPoint_helper(other, &obj) ) {
3036 PyErr_Clear();
3037 return false;
3038 }
3039 return self->operator==(*obj);
3040 }
3041 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3042 wxRealPoint temp, *obj = &temp;
3043 if ( other == Py_None ) return true;
3044 if ( ! wxRealPoint_helper(other, &obj)) {
3045 PyErr_Clear();
3046 return true;
3047 }
3048 return self->operator!=(*obj);
3049 }
3050 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3051 self->x = x;
3052 self->y = y;
3053 }
3054 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3055 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3056 PyObject* tup = PyTuple_New(2);
3057 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3058 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3059 //PyEndBlockThreads(blocked);
3060 return tup;
3061 }
3062 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3063 wxPoint temp, *obj = &temp;
3064 if ( other == Py_None ) return false;
3065 if ( ! wxPoint_helper(other, &obj) ) {
3066 PyErr_Clear();
3067 return false;
3068 }
3069 return self->operator==(*obj);
3070 }
3071 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3072 wxPoint temp, *obj = &temp;
3073 if ( other == Py_None ) return true;
3074 if ( ! wxPoint_helper(other, &obj)) {
3075 PyErr_Clear();
3076 return true;
3077 }
3078 return self->operator!=(*obj);
3079 }
3080 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3081 self->x = x;
3082 self->y = y;
3083 }
3084 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3085 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3086 PyObject* tup = PyTuple_New(2);
3087 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3088 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3089 //wxPyEndBlockThreads(blocked);
3090 return tup;
3091 }
3092 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3093 wxRect temp, *obj = &temp;
3094 if ( other == Py_None ) return false;
3095 if ( ! wxRect_helper(other, &obj) ) {
3096 PyErr_Clear();
3097 return false;
3098 }
3099 return self->operator==(*obj);
3100 }
3101 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3102 wxRect temp, *obj = &temp;
3103 if ( other == Py_None ) return true;
3104 if ( ! wxRect_helper(other, &obj)) {
3105 PyErr_Clear();
3106 return true;
3107 }
3108 return self->operator!=(*obj);
3109 }
3110 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3111 self->x = x;
3112 self->y = y;
3113 self->width = width;
3114 self->height = height;
3115 }
3116 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3117 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3118 PyObject* tup = PyTuple_New(4);
3119 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3120 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3121 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3122 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3123 //wxPyEndBlockThreads(blocked);
3124 return tup;
3125 }
3126
3127 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3128 wxRegion reg1(*r1);
3129 wxRegion reg2(*r2);
3130 wxRect dest(0,0,0,0);
3131 PyObject* obj;
3132
3133 reg1.Intersect(reg2);
3134 dest = reg1.GetBox();
3135
3136 if (dest != wxRect(0,0,0,0)) {
3137 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3138 wxRect* newRect = new wxRect(dest);
3139 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3140 //wxPyEndBlockThreads(blocked);
3141 return obj;
3142 }
3143 Py_INCREF(Py_None);
3144 return Py_None;
3145 }
3146
3147 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3148 wxPoint2D temp, *obj = &temp;
3149 if ( other == Py_None ) return false;
3150 if ( ! wxPoint2D_helper(other, &obj) ) {
3151 PyErr_Clear();
3152 return false;
3153 }
3154 return self->operator==(*obj);
3155 }
3156 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3157 wxPoint2D temp, *obj = &temp;
3158 if ( other == Py_None ) return true;
3159 if ( ! wxPoint2D_helper(other, &obj)) {
3160 PyErr_Clear();
3161 return true;
3162 }
3163 return self->operator!=(*obj);
3164 }
3165 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3166 self->m_x = x;
3167 self->m_y = y;
3168 }
3169 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3170 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3171 PyObject* tup = PyTuple_New(2);
3172 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3173 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3174 //wxPyEndBlockThreads(blocked);
3175 return tup;
3176 }
3177 SWIGINTERN bool wxRect2D___eq__(wxRect2D *self,PyObject *other){
3178 wxRect2D temp, *obj = &temp;
3179 if ( other == Py_None ) return false;
3180 if ( ! wxRect2D_helper(other, &obj) ) {
3181 PyErr_Clear();
3182 return false;
3183 }
3184 return self->operator==(*obj);
3185 }
3186 SWIGINTERN bool wxRect2D___ne__(wxRect2D *self,PyObject *other){
3187 wxRect2D temp, *obj = &temp;
3188 if ( other == Py_None ) return true;
3189 if ( ! wxRect2D_helper(other, &obj)) {
3190 PyErr_Clear();
3191 return true;
3192 }
3193 return self->operator!=(*obj);
3194 }
3195 SWIGINTERN void wxRect2D_Set(wxRect2D *self,wxDouble x=0,wxDouble y=0,wxDouble width=0,wxDouble height=0){
3196 self->m_x = x;
3197 self->m_y = y;
3198 self->m_width = width;
3199 self->m_height = height;
3200 }
3201 SWIGINTERN PyObject *wxRect2D_Get(wxRect2D *self){
3202 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3203 PyObject* tup = PyTuple_New(4);
3204 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3205 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3206 PyTuple_SET_ITEM(tup, 2, PyFloat_FromDouble(self->m_width));
3207 PyTuple_SET_ITEM(tup, 3, PyFloat_FromDouble(self->m_height));
3208 //wxPyEndBlockThreads(blocked);
3209 return tup;
3210 }
3211
3212 #include "wx/wxPython/pyistream.h"
3213
3214 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3215 wxInputStream* wxis = wxPyCBInputStream::create(p);
3216 if (wxis)
3217 return new wxPyInputStream(wxis);
3218 else
3219 return NULL;
3220 }
3221
3222 SWIGINTERN swig_type_info*
3223 SWIG_pchar_descriptor()
3224 {
3225 static int init = 0;
3226 static swig_type_info* info = 0;
3227 if (!init) {
3228 info = SWIG_TypeQuery("_p_char");
3229 init = 1;
3230 }
3231 return info;
3232 }
3233
3234
3235 SWIGINTERNINLINE PyObject *
3236 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3237 {
3238 if (carray) {
3239 if (size > INT_MAX) {
3240 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3241 return pchar_descriptor ?
3242 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3243 } else {
3244 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3245 }
3246 } else {
3247 return SWIG_Py_Void();
3248 }
3249 }
3250
3251
3252 SWIGINTERNINLINE PyObject *
3253 SWIG_From_char (char c)
3254 {
3255 return SWIG_FromCharPtrAndSize(&c,1);
3256 }
3257
3258
3259 SWIGINTERNINLINE PyObject*
3260 SWIG_From_unsigned_SS_long (unsigned long value)
3261 {
3262 return (value > LONG_MAX) ?
3263 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3264 }
3265
3266
3267 SWIGINTERNINLINE PyObject *
3268 SWIG_From_size_t (size_t value)
3269 {
3270 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3271 }
3272
3273
3274 SWIGINTERN int
3275 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3276 {
3277 if (PyString_Check(obj)) {
3278 char *cstr; Py_ssize_t len;
3279 PyString_AsStringAndSize(obj, &cstr, &len);
3280 if (cptr) {
3281 if (alloc) {
3282 /*
3283 In python the user should not be able to modify the inner
3284 string representation. To warranty that, if you define
3285 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3286 buffer is always returned.
3287
3288 The default behavior is just to return the pointer value,
3289 so, be careful.
3290 */
3291 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3292 if (*alloc != SWIG_OLDOBJ)
3293 #else
3294 if (*alloc == SWIG_NEWOBJ)
3295 #endif
3296 {
3297 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3298 *alloc = SWIG_NEWOBJ;
3299 }
3300 else {
3301 *cptr = cstr;
3302 *alloc = SWIG_OLDOBJ;
3303 }
3304 } else {
3305 *cptr = PyString_AsString(obj);
3306 }
3307 }
3308 if (psize) *psize = len + 1;
3309 return SWIG_OK;
3310 } else {
3311 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3312 if (pchar_descriptor) {
3313 void* vptr = 0;
3314 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3315 if (cptr) *cptr = (char *) vptr;
3316 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3317 if (alloc) *alloc = SWIG_OLDOBJ;
3318 return SWIG_OK;
3319 }
3320 }
3321 }
3322 return SWIG_TypeError;
3323 }
3324
3325
3326 SWIGINTERN int
3327 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3328 {
3329 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3330 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3331 if (SWIG_IsOK(res)) {
3332 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3333 if (csize <= size) {
3334 if (val) {
3335 if (csize) memcpy(val, cptr, csize*sizeof(char));
3336 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3337 }
3338 if (alloc == SWIG_NEWOBJ) {
3339 delete[] cptr;
3340 res = SWIG_DelNewMask(res);
3341 }
3342 return res;
3343 }
3344 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3345 }
3346 return SWIG_TypeError;
3347 }
3348
3349
3350 SWIGINTERN int
3351 SWIG_AsVal_char (PyObject * obj, char *val)
3352 {
3353 int res = SWIG_AsCharArray(obj, val, 1);
3354 if (!SWIG_IsOK(res)) {
3355 long v;
3356 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3357 if (SWIG_IsOK(res)) {
3358 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3359 if (val) *val = static_cast< char >(v);
3360 } else {
3361 res = SWIG_OverflowError;
3362 }
3363 }
3364 }
3365 return res;
3366 }
3367
3368 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3369 // We use only strings for the streams, not unicode
3370 PyObject* str = PyObject_Str(obj);
3371 if (! str) {
3372 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3373 return;
3374 }
3375 self->Write(PyString_AS_STRING(str),
3376 PyString_GET_SIZE(str));
3377 Py_DECREF(str);
3378 }
3379
3380 #include "wx/wxPython/pyistream.h"
3381
3382
3383 class wxPyFileSystemHandler : public wxFileSystemHandler
3384 {
3385 public:
3386 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3387
3388 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3389 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3390 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3391 DEC_PYCALLBACK_STRING__pure(FindNext);
3392
3393 wxString GetProtocol(const wxString& location) {
3394 return wxFileSystemHandler::GetProtocol(location);
3395 }
3396
3397 wxString GetLeftLocation(const wxString& location) {
3398 return wxFileSystemHandler::GetLeftLocation(location);
3399 }
3400
3401 wxString GetAnchor(const wxString& location) {
3402 return wxFileSystemHandler::GetAnchor(location);
3403 }
3404
3405 wxString GetRightLocation(const wxString& location) {
3406 return wxFileSystemHandler::GetRightLocation(location);
3407 }
3408
3409 wxString GetMimeTypeFromExt(const wxString& location) {
3410 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3411 }
3412
3413 PYPRIVATE;
3414 };
3415
3416
3417 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3418 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3419 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3420 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3421
3422
3423 SWIGINTERN int
3424 SWIG_AsVal_bool (PyObject *obj, bool *val)
3425 {
3426 if (obj == Py_True) {
3427 if (val) *val = true;
3428 return SWIG_OK;
3429 } else if (obj == Py_False) {
3430 if (val) *val = false;
3431 return SWIG_OK;
3432 } else {
3433 long v = 0;
3434 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3435 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3436 return res;
3437 }
3438 }
3439
3440 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3441 wxFileName fname = wxFileSystem::URLToFileName(url);
3442 return fname.GetFullPath();
3443 }
3444
3445 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3446 wxImage& image,
3447 long type) {
3448 wxMemoryFSHandler::AddFile(filename, image, type);
3449 }
3450
3451 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3452 const wxBitmap& bitmap,
3453 long type) {
3454 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3455 }
3456
3457 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3458 PyObject* data) {
3459 if (! PyString_Check(data)) {
3460 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3461 "Expected string object"));
3462 return;
3463 }
3464
3465 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3466 void* ptr = (void*)PyString_AsString(data);
3467 size_t size = PyString_Size(data);
3468 wxPyEndBlockThreads(blocked);
3469
3470 wxMemoryFSHandler::AddFile(filename, ptr, size);
3471 }
3472
3473
3474 #include "wx/wxPython/pyistream.h"
3475
3476
3477 SWIGINTERN int
3478 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3479 {
3480 long v = 0;
3481 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3482 return SWIG_TypeError;
3483 }
3484 else if (val)
3485 *val = (unsigned long)v;
3486 return SWIG_OK;
3487 }
3488
3489
3490 SWIGINTERN int
3491 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3492 {
3493 unsigned long v;
3494 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3495 if (SWIG_IsOK(res)) {
3496 if ((v > UCHAR_MAX)) {
3497 return SWIG_OverflowError;
3498 } else {
3499 if (val) *val = static_cast< unsigned char >(v);
3500 }
3501 }
3502 return res;
3503 }
3504
3505
3506 SWIGINTERNINLINE PyObject *
3507 SWIG_From_unsigned_SS_char (unsigned char value)
3508 {
3509 return SWIG_From_unsigned_SS_long (value);
3510 }
3511
3512 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3513 wxImageHistogramEntry e = (*self)[key];
3514 return e.value;
3515 }
3516 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3517 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3518 wxImageHistogramEntry e = (*self)[key];
3519 return e.value;
3520 }
3521 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3522 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3523 colour.Green(),
3524 colour.Blue());
3525 wxImageHistogramEntry e = (*self)[key];
3526 return e.value;
3527 }
3528
3529 // Pull the nested class out to the top level for SWIG's sake
3530 #define wxImage_RGBValue wxImage::RGBValue
3531 #define wxImage_HSVValue wxImage::HSVValue
3532
3533 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3534 if (width > 0 && height > 0)
3535 return new wxImage(width, height, clear);
3536 else
3537 return new wxImage;
3538 }
3539 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3540 return new wxImage(bitmap.ConvertToImage());
3541 }
3542 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3543 if (DATASIZE != width*height*3) {
3544 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3545 return NULL;
3546 }
3547
3548 // Copy the source data so the wxImage can clean it up later
3549 buffer copy = (buffer)malloc(DATASIZE);
3550 if (copy == NULL) {
3551 wxPyBLOCK_THREADS(PyErr_NoMemory());
3552 return NULL;
3553 }
3554 memcpy(copy, data, DATASIZE);
3555 return new wxImage(width, height, copy, false);
3556 }
3557 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3558 if (DATASIZE != width*height*3) {
3559 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3560 return NULL;
3561 }
3562 if (ALPHASIZE != width*height) {
3563 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3564 return NULL;
3565 }
3566
3567 // Copy the source data so the wxImage can clean it up later
3568 buffer dcopy = (buffer)malloc(DATASIZE);
3569 if (dcopy == NULL) {
3570 wxPyBLOCK_THREADS(PyErr_NoMemory());
3571 return NULL;
3572 }
3573 memcpy(dcopy, data, DATASIZE);
3574
3575 buffer acopy = (buffer)malloc(ALPHASIZE);
3576 if (acopy == NULL) {
3577 wxPyBLOCK_THREADS(PyErr_NoMemory());
3578 return NULL;
3579 }
3580 memcpy(acopy, alpha, ALPHASIZE);
3581
3582 return new wxImage(width, height, dcopy, acopy, false);
3583 }
3584 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3585 wxSize size(self->GetWidth(), self->GetHeight());
3586 return size;
3587 }
3588 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3589 buffer data = self->GetData();
3590 int len = self->GetWidth() * self->GetHeight() * 3;
3591 PyObject* rv;
3592 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3593 return rv;
3594 }
3595 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3596 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3597 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3598 return;
3599 }
3600 buffer copy = (buffer)malloc(DATASIZE);
3601 if (copy == NULL) {
3602 wxPyBLOCK_THREADS(PyErr_NoMemory());
3603 return;
3604 }
3605 memcpy(copy, data, DATASIZE);
3606 self->SetData(copy, false);
3607 // wxImage takes ownership of copy...
3608 }
3609 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3610 buffer data = self->GetData();
3611 int len = self->GetWidth() * self->GetHeight() * 3;
3612 PyObject* rv;
3613 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3614 return rv;
3615 }
3616 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3617 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3618 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3619 return;
3620 }
3621 self->SetData(data, true);
3622 }
3623 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3624 buffer data = self->GetAlpha();
3625 if (! data) {
3626 RETURN_NONE();
3627 } else {
3628 int len = self->GetWidth() * self->GetHeight();
3629 PyObject* rv;
3630 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3631 return rv;
3632 }
3633 }
3634 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3635 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3636 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3637 return;
3638 }
3639 buffer acopy = (buffer)malloc(ALPHASIZE);
3640 if (acopy == NULL) {
3641 wxPyBLOCK_THREADS(PyErr_NoMemory());
3642 return;
3643 }
3644 memcpy(acopy, alpha, ALPHASIZE);
3645 self->SetAlpha(acopy, false);
3646 // wxImage takes ownership of acopy...
3647 }
3648 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3649 buffer data = self->GetAlpha();
3650 int len = self->GetWidth() * self->GetHeight();
3651 PyObject* rv;
3652 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3653 return rv;
3654 }
3655 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3656 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3657 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3658 return;
3659 }
3660 self->SetAlpha(alpha, true);
3661 }
3662 SWIGINTERN PyObject *wxImage_GetHandlers(){
3663 wxList& list = wxImage::GetHandlers();
3664 return wxPy_ConvertList(&list);
3665 }
3666 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3667 wxBitmap bitmap(*self, depth);
3668 return bitmap;
3669 }
3670 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3671 wxImage mono = self->ConvertToMono( red, green, blue );
3672 wxBitmap bitmap( mono, 1 );
3673 return bitmap;
3674 }
3675
3676 wxImage* _ImageFromBuffer(int width, int height,
3677 buffer data, int DATASIZE,
3678 buffer alpha=NULL, int ALPHASIZE=0)
3679 {
3680 if (DATASIZE != width*height*3) {
3681 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3682 return NULL;
3683 }
3684 if (alpha != NULL) {
3685 if (ALPHASIZE != width*height) {
3686 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3687 return NULL;
3688 }
3689 return new wxImage(width, height, data, alpha, true);
3690 }
3691 return new wxImage(width, height, data, true);
3692 }
3693
3694 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3695 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3696 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3697 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3698 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3699 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3700 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3701 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3702 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3703 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3704 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3705 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3706 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3707 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3708 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3709
3710 #include <wx/imagtga.h>
3711
3712
3713 #include <wx/quantize.h>
3714
3715 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3716 return wxQuantize::Quantize(src, dest,
3717 //NULL, // palette
3718 desiredNoColours,
3719 NULL, // eightBitData
3720 flags);
3721 }
3722 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3723 if (PyCallable_Check(func)) {
3724 self->Connect(id, lastId, eventType,
3725 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3726 new wxPyCallback(func));
3727 }
3728 else if (func == Py_None) {
3729 self->Disconnect(id, lastId, eventType,
3730 (wxObjectEventFunction)
3731 &wxPyCallback::EventThunker);
3732 }
3733 else {
3734 wxPyBLOCK_THREADS(
3735 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3736 }
3737 }
3738 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3739 return self->Disconnect(id, lastId, eventType,
3740 (wxObjectEventFunction)
3741 &wxPyCallback::EventThunker);
3742 }
3743 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3744 if (_self && _self != Py_None) {
3745 self->SetClientObject(new wxPyOORClientData(_self, incref));
3746 }
3747 else {
3748 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3749 if (data) {
3750 self->SetClientObject(NULL); // This will delete it too
3751 }
3752 }
3753 }
3754
3755 #if ! wxUSE_HOTKEY
3756 #define wxEVT_HOTKEY -9999
3757 #endif
3758
3759 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3760 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3761 if (data) {
3762 Py_INCREF(data->m_obj);
3763 return data->m_obj;
3764 } else {
3765 Py_INCREF(Py_None);
3766 return Py_None;
3767 }
3768 }
3769 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3770 wxPyClientData* data = new wxPyClientData(clientData);
3771 self->SetClientObject(data);
3772 }
3773 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3774 #if wxUSE_UNICODE
3775 return self->GetUnicodeKey();
3776 #else
3777 return 0;
3778 #endif
3779 }
3780 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3781 #if wxUSE_UNICODE
3782 self->m_uniChar = uniChar;
3783 #endif
3784 }
3785
3786 SWIGINTERNINLINE PyObject *
3787 SWIG_From_unsigned_SS_int (unsigned int value)
3788 {
3789 return SWIG_From_unsigned_SS_long (value);
3790 }
3791
3792
3793 SWIGINTERN int
3794 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3795 {
3796 unsigned long v;
3797 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3798 if (SWIG_IsOK(res)) {
3799 if ((v > UINT_MAX)) {
3800 return SWIG_OverflowError;
3801 } else {
3802 if (val) *val = static_cast< unsigned int >(v);
3803 }
3804 }
3805 return res;
3806 }
3807
3808 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3809 self->m_size = size;
3810 }
3811 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3812 int count = self->GetNumberOfFiles();
3813 wxString* files = self->GetFiles();
3814 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3815 PyObject* list = PyList_New(count);
3816
3817 if (!list) {
3818 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3819 wxPyEndBlockThreads(blocked);
3820 return NULL;
3821 }
3822
3823 for (int i=0; i<count; i++) {
3824 PyList_SetItem(list, i, wx2PyString(files[i]));
3825 }
3826 wxPyEndBlockThreads(blocked);
3827 return list;
3828 }
3829
3830
3831 SWIGINTERN wxPyApp *new_wxPyApp(){
3832 wxPythonApp = new wxPyApp();
3833 return wxPythonApp;
3834 }
3835 SWIGINTERN int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
3836 SWIGINTERN bool wxPyApp_IsDisplayAvailable(){
3837 return wxPyTestDisplayAvailable();
3838 }
3839
3840 void wxApp_CleanUp() {
3841 __wxPyCleanup();
3842 }
3843
3844
3845 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3846
3847
3848
3849
3850
3851 SWIGINTERNINLINE PyObject *
3852 SWIG_FromCharPtr(const char *cptr)
3853 {
3854 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3855 }
3856
3857
3858 #if 0 // #ifdef __WXMAC__
3859
3860 // A dummy class that raises an exception if used...
3861 class wxEventLoop
3862 {
3863 public:
3864 wxEventLoop() { wxPyRaiseNotImplemented(); }
3865 int Run() { return 0; }
3866 void Exit(int rc = 0) {}
3867 bool Pending() const { return false; }
3868 bool Dispatch() { return false; }
3869 bool IsRunning() const { return false; }
3870 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3871 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3872 };
3873
3874 #else
3875
3876 #include <wx/evtloop.h>
3877
3878 #endif
3879
3880
3881
3882 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3883 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3884 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3885 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3886 wxWindowList& list = self->GetChildren();
3887 return wxPy_ConvertList(&list);
3888 }
3889 SWIGINTERN wxWindow *wxWindow_GetTopLevelParent(wxWindow *self){
3890 return wxGetTopLevelParent(self);
3891 }
3892 SWIGINTERN void wxWindow_SetDoubleBuffered(wxWindow *self,bool on){}
3893 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3894 #if wxUSE_HOTKEY
3895 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3896 #else
3897 return false;
3898 #endif
3899 }
3900 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3901
3902
3903
3904 return false;
3905
3906 }
3907 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3908 return wxPyGetWinHandle(self);
3909 }
3910 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3911 self->AssociateHandle((WXWidget)handle);
3912 }
3913 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3914
3915 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3916 return wxWindow::FindWindowById(id, parent);
3917 }
3918
3919 wxWindow* wxFindWindowByName( const wxString& name,
3920 const wxWindow *parent = NULL ) {
3921 return wxWindow::FindWindowByName(name, parent);
3922 }
3923
3924 wxWindow* wxFindWindowByLabel( const wxString& label,
3925 const wxWindow *parent = NULL ) {
3926 return wxWindow::FindWindowByLabel(label, parent);
3927 }
3928
3929
3930 #ifdef __WXMSW__
3931 #include <wx/msw/private.h> // to get wxGetWindowId
3932 #endif
3933
3934
3935 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3936 #ifdef __WXMSW__
3937 WXHWND hWnd = (WXHWND)_hWnd;
3938 long id = wxGetWindowId(hWnd);
3939 wxWindow* win = new wxWindow;
3940 if (parent)
3941 parent->AddChild(win);
3942 win->SetEventHandler(win);
3943 win->SetHWND(hWnd);
3944 win->SetId(id);
3945 win->SubclassWin(hWnd);
3946 win->AdoptAttributesFromHWND();
3947 win->SetupColours();
3948 return win;
3949 #else
3950 wxPyRaiseNotImplemented();
3951 return NULL;
3952 #endif
3953 }
3954
3955
3956 PyObject* GetTopLevelWindows() {
3957 return wxPy_ConvertList(&wxTopLevelWindows);
3958 }
3959
3960
3961 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3962 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3963 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3964
3965 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3966
3967
3968 SWIGINTERNINLINE int
3969 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3970 {
3971 unsigned long v;
3972 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3973 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3974 return res;
3975 }
3976
3977 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3978 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3979 wxMenuItemList& list = self->GetMenuItems();
3980 return wxPy_ConvertList(&list);
3981 }
3982 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
3983 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
3984 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
3985 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
3986 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
3987 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
3988 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
3989 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
3990 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
3991 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
3992 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
3993 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
3994 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
3995 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
3996 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
3997 static const wxString wxPyControlNameStr(wxControlNameStr);
3998 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3999 if (clientData) {
4000 wxPyClientData* data = new wxPyClientData(clientData);
4001 return self->Append(item, data);
4002 } else
4003 return self->Append(item);
4004 }
4005 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
4006 if (clientData) {
4007 wxPyClientData* data = new wxPyClientData(clientData);
4008 return self->Insert(item, pos, data);
4009 } else
4010 return self->Insert(item, pos);
4011 }
4012 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
4013 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
4014 if (data) {
4015 Py_INCREF(data->m_obj);
4016 return data->m_obj;
4017 } else {
4018 Py_INCREF(Py_None);
4019 return Py_None;
4020 }
4021 }
4022 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
4023 wxPyClientData* data = new wxPyClientData(clientData);
4024 self->SetClientObject(n, data);
4025 }
4026
4027
4028 SWIGINTERN wxSizerFlags &wxSizerFlags_Border(wxSizerFlags *self,int direction=wxALL,int borderInPixels=-1){
4029 if (borderInPixels == -1)
4030 return self->Border(direction);
4031 else
4032 return self->Border(direction, borderInPixels);
4033 }
4034 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,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(window, proportion, flag, border, data);
4042 }
4043 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,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(width, height, proportion, flag, border, data);
4051 }
4052 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
4053 wxPyUserData* data = NULL;
4054 if ( userData ) {
4055 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4056 data = new wxPyUserData(userData);
4057 wxPyEndBlockThreads(blocked);
4058 }
4059 return new wxSizerItem(sizer, proportion, flag, border, data);
4060 }
4061
4062 SWIGINTERNINLINE PyObject *
4063 SWIG_From_float (float value)
4064 {
4065 return SWIG_From_double (value);
4066 }
4067
4068 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
4069 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
4070 if (data) {
4071 Py_INCREF(data->m_obj);
4072 return data->m_obj;
4073 } else {
4074 Py_INCREF(Py_None);
4075 return Py_None;
4076 }
4077 }
4078 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4079 wxPyUserData* data = NULL;
4080 if ( userData ) {
4081 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4082 data = new wxPyUserData(userData);
4083 wxPyEndBlockThreads(blocked);
4084 }
4085 self->SetUserData(data);
4086 }
4087
4088 // Figure out the type of the sizer item
4089
4090 struct wxPySizerItemInfo {
4091 wxPySizerItemInfo()
4092 : window(NULL), sizer(NULL), gotSize(false),
4093 size(wxDefaultSize), gotPos(false), pos(-1)
4094 {}
4095
4096 wxWindow* window;
4097 wxSizer* sizer;
4098 bool gotSize;
4099 wxSize size;
4100 bool gotPos;
4101 int pos;
4102 };
4103
4104 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4105
4106 wxPySizerItemInfo info;
4107 wxSize size;
4108 wxSize* sizePtr = &size;
4109
4110 // Find out what the type of the item is
4111 // try wxWindow
4112 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4113 PyErr_Clear();
4114 info.window = NULL;
4115
4116 // try wxSizer
4117 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4118 PyErr_Clear();
4119 info.sizer = NULL;
4120
4121 // try wxSize or (w,h)
4122 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4123 info.size = *sizePtr;
4124 info.gotSize = true;
4125 }
4126
4127 // or a single int
4128 if (checkIdx && PyInt_Check(item)) {
4129 info.pos = PyInt_AsLong(item);
4130 info.gotPos = true;
4131 }
4132 }
4133 }
4134
4135 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4136 // no expected type, figure out what kind of error message to generate
4137 if ( !checkSize && !checkIdx )
4138 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4139 else if ( checkSize && !checkIdx )
4140 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4141 else if ( !checkSize && checkIdx)
4142 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4143 else
4144 // can this one happen?
4145 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4146 }
4147
4148 return info;
4149 }
4150
4151 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4152 if (!self->GetClientObject())
4153 self->SetClientObject(new wxPyOORClientData(_self));
4154 }
4155 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4156
4157 wxPyUserData* data = NULL;
4158 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4159 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4160 if ( userData && (info.window || info.sizer || info.gotSize) )
4161 data = new wxPyUserData(userData);
4162 if ( info.sizer )
4163 PyObject_SetAttrString(item,"thisown",Py_False);
4164 wxPyEndBlockThreads(blocked);
4165
4166 // Now call the real Add method if a valid item type was found
4167 if ( info.window )
4168 return self->Add(info.window, proportion, flag, border, data);
4169 else if ( info.sizer )
4170 return self->Add(info.sizer, proportion, flag, border, data);
4171 else if (info.gotSize)
4172 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4173 proportion, flag, border, data);
4174 else
4175 return NULL;
4176 }
4177 SWIGINTERN wxSizerItem *wxSizer_AddF(wxSizer *self,PyObject *item,wxSizerFlags &flags){
4178
4179 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4180 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4181 if ( info.sizer )
4182 PyObject_SetAttrString(item,"thisown",Py_False);
4183 wxPyEndBlockThreads(blocked);
4184
4185 // Now call the real Add method if a valid item type was found
4186 if ( info.window )
4187 return self->Add(info.window, flags);
4188 else if ( info.sizer )
4189 return self->Add(info.sizer, flags);
4190 else if (info.gotSize)
4191 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4192 flags.GetProportion(),
4193 flags.GetFlags(),
4194 flags.GetBorderInPixels());
4195 else
4196 return NULL;
4197 }
4198 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4199
4200 wxPyUserData* data = NULL;
4201 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4202 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4203 if ( userData && (info.window || info.sizer || info.gotSize) )
4204 data = new wxPyUserData(userData);
4205 if ( info.sizer )
4206 PyObject_SetAttrString(item,"thisown",Py_False);
4207 wxPyEndBlockThreads(blocked);
4208
4209 // Now call the real Insert method if a valid item type was found
4210 if ( info.window )
4211 return self->Insert(before, info.window, proportion, flag, border, data);
4212 else if ( info.sizer )
4213 return self->Insert(before, info.sizer, proportion, flag, border, data);
4214 else if (info.gotSize)
4215 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4216 proportion, flag, border, data);
4217 else
4218 return NULL;
4219 }
4220 SWIGINTERN wxSizerItem *wxSizer_InsertF(wxSizer *self,int before,PyObject *item,wxSizerFlags &flags){
4221
4222 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4223 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4224 if ( info.sizer )
4225 PyObject_SetAttrString(item,"thisown",Py_False);
4226 wxPyEndBlockThreads(blocked);
4227
4228 // Now call the real Insert method if a valid item type was found
4229 if ( info.window )
4230 return self->Insert(before, info.window, flags);
4231 else if ( info.sizer )
4232 return self->Insert(before, info.sizer, flags);
4233 else if (info.gotSize)
4234 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4235 flags.GetProportion(),
4236 flags.GetFlags(),
4237 flags.GetBorderInPixels());
4238 else
4239 return NULL;
4240 }
4241 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4242
4243 wxPyUserData* data = NULL;
4244 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4245 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4246 if ( userData && (info.window || info.sizer || info.gotSize) )
4247 data = new wxPyUserData(userData);
4248 if ( info.sizer )
4249 PyObject_SetAttrString(item,"thisown",Py_False);
4250 wxPyEndBlockThreads(blocked);
4251
4252 // Now call the real Prepend method if a valid item type was found
4253 if ( info.window )
4254 return self->Prepend(info.window, proportion, flag, border, data);
4255 else if ( info.sizer )
4256 return self->Prepend(info.sizer, proportion, flag, border, data);
4257 else if (info.gotSize)
4258 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4259 proportion, flag, border, data);
4260 else
4261 return NULL;
4262 }
4263 SWIGINTERN wxSizerItem *wxSizer_PrependF(wxSizer *self,PyObject *item,wxSizerFlags &flags){
4264
4265 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4266 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4267 if ( info.sizer )
4268 PyObject_SetAttrString(item,"thisown",Py_False);
4269 wxPyEndBlockThreads(blocked);
4270
4271 // Now call the real Add method if a valid item type was found
4272 if ( info.window )
4273 return self->Prepend(info.window, flags);
4274 else if ( info.sizer )
4275 return self->Prepend(info.sizer, flags);
4276 else if (info.gotSize)
4277 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4278 flags.GetProportion(),
4279 flags.GetFlags(),
4280 flags.GetBorderInPixels());
4281 else
4282 return NULL;
4283 }
4284 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4285 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4286 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4287 wxPyEndBlockThreads(blocked);
4288 if ( info.window )
4289 return false; //self->Remove(info.window);
4290 else if ( info.sizer )
4291 return self->Remove(info.sizer);
4292 else if ( info.gotPos )
4293 return self->Remove(info.pos);
4294 else
4295 return false;
4296 }
4297 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4298 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4299 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4300 wxPyEndBlockThreads(blocked);
4301 if ( info.window )
4302 return self->Detach(info.window);
4303 else if ( info.sizer )
4304 return self->Detach(info.sizer);
4305 else if ( info.gotPos )
4306 return self->Detach(info.pos);
4307 else
4308 return false;
4309 }
4310 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item,bool recursive=false){
4311 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4312 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4313 wxPyEndBlockThreads(blocked);
4314 if ( info.window )
4315 return self->GetItem(info.window, recursive);
4316 else if ( info.sizer )
4317 return self->GetItem(info.sizer, recursive);
4318 else if ( info.gotPos )
4319 return self->GetItem(info.pos);
4320 else
4321 return NULL;
4322 }
4323 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4324 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4325 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4326 wxPyEndBlockThreads(blocked);
4327 if ( info.window )
4328 self->SetItemMinSize(info.window, size);
4329 else if ( info.sizer )
4330 self->SetItemMinSize(info.sizer, size);
4331 else if ( info.gotPos )
4332 self->SetItemMinSize(info.pos, size);
4333 }
4334 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4335 wxSizerItemList& list = self->GetChildren();
4336 return wxPy_ConvertList(&list);
4337 }
4338 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4339 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4340 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4341 wxPyEndBlockThreads(blocked);
4342 if ( info.window )
4343 return self->Show(info.window, show, recursive);
4344 else if ( info.sizer )
4345 return self->Show(info.sizer, show, recursive);
4346 else if ( info.gotPos )
4347 return self->Show(info.pos, show);
4348 else
4349 return false;
4350 }
4351 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4352 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4353 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4354 wxPyEndBlockThreads(blocked);
4355 if ( info.window )
4356 return self->IsShown(info.window);
4357 else if ( info.sizer )
4358 return self->IsShown(info.sizer);
4359 else if ( info.gotPos )
4360 return self->IsShown(info.pos);
4361 else
4362 return false;
4363 }
4364
4365 // See pyclasses.h
4366 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4367 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4368 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4369
4370
4371
4372
4373 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4374 {
4375 if (source == Py_None) {
4376 **obj = wxGBPosition(-1,-1);
4377 return true;
4378 }
4379 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4380 }
4381
4382 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4383 {
4384 if (source == Py_None) {
4385 **obj = wxGBSpan(-1,-1);
4386 return true;
4387 }
4388 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4389 }
4390
4391
4392 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4393 wxGBPosition temp, *obj = &temp;
4394 if ( other == Py_None ) return false;
4395 if ( ! wxGBPosition_helper(other, &obj) ) {
4396 PyErr_Clear();
4397 return false;
4398 }
4399 return self->operator==(*obj);
4400 }
4401 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4402 wxGBPosition temp, *obj = &temp;
4403 if ( other == Py_None ) return true;
4404 if ( ! wxGBPosition_helper(other, &obj)) {
4405 PyErr_Clear();
4406 return true;
4407 }
4408 return self->operator!=(*obj);
4409 }
4410 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4411 self->SetRow(row);
4412 self->SetCol(col);
4413 }
4414 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4415 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4416 PyObject* tup = PyTuple_New(2);
4417 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4418 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4419 wxPyEndBlockThreads(blocked);
4420 return tup;
4421 }
4422 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4423 wxGBSpan temp, *obj = &temp;
4424 if ( other == Py_None ) return false;
4425 if ( ! wxGBSpan_helper(other, &obj) ) {
4426 PyErr_Clear();
4427 return false;
4428 }
4429 return self->operator==(*obj);
4430 }
4431 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4432 wxGBSpan temp, *obj = &temp;
4433 if ( other == Py_None ) return true;
4434 if ( ! wxGBSpan_helper(other, &obj)) {
4435 PyErr_Clear();
4436 return true;
4437 }
4438 return self->operator!=(*obj);
4439 }
4440 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4441 self->SetRowspan(rowspan);
4442 self->SetColspan(colspan);
4443 }
4444 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4445 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4446 PyObject* tup = PyTuple_New(2);
4447 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4448 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4449 wxPyEndBlockThreads(blocked);
4450 return tup;
4451 }
4452 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4453 wxPyUserData* data = NULL;
4454 if ( userData ) {
4455 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4456 data = new wxPyUserData(userData);
4457 wxPyEndBlockThreads(blocked);
4458 }
4459 return new wxGBSizerItem(window, pos, span, flag, border, data);
4460 }
4461 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4462 wxPyUserData* data = NULL;
4463 if ( userData ) {
4464 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4465 data = new wxPyUserData(userData);
4466 wxPyEndBlockThreads(blocked);
4467 }
4468 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4469 }
4470 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4471 wxPyUserData* data = NULL;
4472 if ( userData ) {
4473 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4474 data = new wxPyUserData(userData);
4475 wxPyEndBlockThreads(blocked);
4476 }
4477 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4478 }
4479 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4480 int row, col;
4481 self->GetEndPos(row, col);
4482 return wxGBPosition(row, col);
4483 }
4484 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4485
4486 wxPyUserData* data = NULL;
4487 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4488 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4489 if ( userData && (info.window || info.sizer || info.gotSize) )
4490 data = new wxPyUserData(userData);
4491 if ( info.sizer )
4492 PyObject_SetAttrString(item,"thisown",Py_False);
4493 wxPyEndBlockThreads(blocked);
4494
4495 // Now call the real Add method if a valid item type was found
4496 if ( info.window )
4497 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4498 else if ( info.sizer )
4499 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4500 else if (info.gotSize)
4501 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4502 pos, span, flag, border, data);
4503 return NULL;
4504 }
4505
4506
4507 #ifdef __cplusplus
4508 extern "C" {
4509 #endif
4510 SWIGINTERN int EmptyString_set(PyObject *) {
4511 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4512 return 1;
4513 }
4514
4515
4516 SWIGINTERN PyObject *EmptyString_get(void) {
4517 PyObject *pyobj = 0;
4518
4519 {
4520 #if wxUSE_UNICODE
4521 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4522 #else
4523 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4524 #endif
4525 }
4526 return pyobj;
4527 }
4528
4529
4530 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4531 PyObject *resultobj = 0;
4532 wxObject *arg1 = (wxObject *) 0 ;
4533 wxString result;
4534 void *argp1 = 0 ;
4535 int res1 = 0 ;
4536 PyObject *swig_obj[1] ;
4537
4538 if (!args) SWIG_fail;
4539 swig_obj[0] = args;
4540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4541 if (!SWIG_IsOK(res1)) {
4542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4543 }
4544 arg1 = reinterpret_cast< wxObject * >(argp1);
4545 {
4546 PyThreadState* __tstate = wxPyBeginAllowThreads();
4547 result = wxObject_GetClassName(arg1);
4548 wxPyEndAllowThreads(__tstate);
4549 if (PyErr_Occurred()) SWIG_fail;
4550 }
4551 {
4552 #if wxUSE_UNICODE
4553 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4554 #else
4555 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4556 #endif
4557 }
4558 return resultobj;
4559 fail:
4560 return NULL;
4561 }
4562
4563
4564 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4565 PyObject *resultobj = 0;
4566 wxObject *arg1 = (wxObject *) 0 ;
4567 void *argp1 = 0 ;
4568 int res1 = 0 ;
4569 PyObject *swig_obj[1] ;
4570
4571 if (!args) SWIG_fail;
4572 swig_obj[0] = args;
4573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4574 if (!SWIG_IsOK(res1)) {
4575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4576 }
4577 arg1 = reinterpret_cast< wxObject * >(argp1);
4578 {
4579 PyThreadState* __tstate = wxPyBeginAllowThreads();
4580 wxObject_Destroy(arg1);
4581 wxPyEndAllowThreads(__tstate);
4582 if (PyErr_Occurred()) SWIG_fail;
4583 }
4584 resultobj = SWIG_Py_Void();
4585 return resultobj;
4586 fail:
4587 return NULL;
4588 }
4589
4590
4591 SWIGINTERN PyObject *_wrap_Object_IsSameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4592 PyObject *resultobj = 0;
4593 wxObject *arg1 = (wxObject *) 0 ;
4594 wxObject *arg2 = 0 ;
4595 bool result;
4596 void *argp1 = 0 ;
4597 int res1 = 0 ;
4598 void *argp2 = 0 ;
4599 int res2 = 0 ;
4600 PyObject * obj0 = 0 ;
4601 PyObject * obj1 = 0 ;
4602 char * kwnames[] = {
4603 (char *) "self",(char *) "p", NULL
4604 };
4605
4606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Object_IsSameAs",kwnames,&obj0,&obj1)) SWIG_fail;
4607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4608 if (!SWIG_IsOK(res1)) {
4609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_IsSameAs" "', expected argument " "1"" of type '" "wxObject const *""'");
4610 }
4611 arg1 = reinterpret_cast< wxObject * >(argp1);
4612 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxObject, 0 | 0);
4613 if (!SWIG_IsOK(res2)) {
4614 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Object_IsSameAs" "', expected argument " "2"" of type '" "wxObject const &""'");
4615 }
4616 if (!argp2) {
4617 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Object_IsSameAs" "', expected argument " "2"" of type '" "wxObject const &""'");
4618 }
4619 arg2 = reinterpret_cast< wxObject * >(argp2);
4620 {
4621 PyThreadState* __tstate = wxPyBeginAllowThreads();
4622 result = (bool)((wxObject const *)arg1)->IsSameAs((wxObject const &)*arg2);
4623 wxPyEndAllowThreads(__tstate);
4624 if (PyErr_Occurred()) SWIG_fail;
4625 }
4626 {
4627 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4628 }
4629 return resultobj;
4630 fail:
4631 return NULL;
4632 }
4633
4634
4635 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4636 PyObject *obj;
4637 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4638 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4639 return SWIG_Py_Void();
4640 }
4641
4642 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4643 PyObject *resultobj = 0;
4644 wxSize *arg1 = (wxSize *) 0 ;
4645 int arg2 ;
4646 void *argp1 = 0 ;
4647 int res1 = 0 ;
4648 int val2 ;
4649 int ecode2 = 0 ;
4650 PyObject *swig_obj[2] ;
4651
4652 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4654 if (!SWIG_IsOK(res1)) {
4655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4656 }
4657 arg1 = reinterpret_cast< wxSize * >(argp1);
4658 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4659 if (!SWIG_IsOK(ecode2)) {
4660 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4661 }
4662 arg2 = static_cast< int >(val2);
4663 if (arg1) (arg1)->x = arg2;
4664
4665 resultobj = SWIG_Py_Void();
4666 return resultobj;
4667 fail:
4668 return NULL;
4669 }
4670
4671
4672 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4673 PyObject *resultobj = 0;
4674 wxSize *arg1 = (wxSize *) 0 ;
4675 int result;
4676 void *argp1 = 0 ;
4677 int res1 = 0 ;
4678 PyObject *swig_obj[1] ;
4679
4680 if (!args) SWIG_fail;
4681 swig_obj[0] = args;
4682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4683 if (!SWIG_IsOK(res1)) {
4684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4685 }
4686 arg1 = reinterpret_cast< wxSize * >(argp1);
4687 result = (int) ((arg1)->x);
4688 resultobj = SWIG_From_int(static_cast< int >(result));
4689 return resultobj;
4690 fail:
4691 return NULL;
4692 }
4693
4694
4695 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4696 PyObject *resultobj = 0;
4697 wxSize *arg1 = (wxSize *) 0 ;
4698 int arg2 ;
4699 void *argp1 = 0 ;
4700 int res1 = 0 ;
4701 int val2 ;
4702 int ecode2 = 0 ;
4703 PyObject *swig_obj[2] ;
4704
4705 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4707 if (!SWIG_IsOK(res1)) {
4708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4709 }
4710 arg1 = reinterpret_cast< wxSize * >(argp1);
4711 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4712 if (!SWIG_IsOK(ecode2)) {
4713 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4714 }
4715 arg2 = static_cast< int >(val2);
4716 if (arg1) (arg1)->y = arg2;
4717
4718 resultobj = SWIG_Py_Void();
4719 return resultobj;
4720 fail:
4721 return NULL;
4722 }
4723
4724
4725 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4726 PyObject *resultobj = 0;
4727 wxSize *arg1 = (wxSize *) 0 ;
4728 int result;
4729 void *argp1 = 0 ;
4730 int res1 = 0 ;
4731 PyObject *swig_obj[1] ;
4732
4733 if (!args) SWIG_fail;
4734 swig_obj[0] = args;
4735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4736 if (!SWIG_IsOK(res1)) {
4737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4738 }
4739 arg1 = reinterpret_cast< wxSize * >(argp1);
4740 result = (int) ((arg1)->y);
4741 resultobj = SWIG_From_int(static_cast< int >(result));
4742 return resultobj;
4743 fail:
4744 return NULL;
4745 }
4746
4747
4748 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4749 PyObject *resultobj = 0;
4750 int arg1 = (int) 0 ;
4751 int arg2 = (int) 0 ;
4752 wxSize *result = 0 ;
4753 int val1 ;
4754 int ecode1 = 0 ;
4755 int val2 ;
4756 int ecode2 = 0 ;
4757 PyObject * obj0 = 0 ;
4758 PyObject * obj1 = 0 ;
4759 char * kwnames[] = {
4760 (char *) "w",(char *) "h", NULL
4761 };
4762
4763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4764 if (obj0) {
4765 ecode1 = SWIG_AsVal_int(obj0, &val1);
4766 if (!SWIG_IsOK(ecode1)) {
4767 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4768 }
4769 arg1 = static_cast< int >(val1);
4770 }
4771 if (obj1) {
4772 ecode2 = SWIG_AsVal_int(obj1, &val2);
4773 if (!SWIG_IsOK(ecode2)) {
4774 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4775 }
4776 arg2 = static_cast< int >(val2);
4777 }
4778 {
4779 result = (wxSize *)new wxSize(arg1,arg2);
4780 if (PyErr_Occurred()) SWIG_fail;
4781 }
4782 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4783 return resultobj;
4784 fail:
4785 return NULL;
4786 }
4787
4788
4789 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4790 PyObject *resultobj = 0;
4791 wxSize *arg1 = (wxSize *) 0 ;
4792 void *argp1 = 0 ;
4793 int res1 = 0 ;
4794 PyObject *swig_obj[1] ;
4795
4796 if (!args) SWIG_fail;
4797 swig_obj[0] = args;
4798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4799 if (!SWIG_IsOK(res1)) {
4800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4801 }
4802 arg1 = reinterpret_cast< wxSize * >(argp1);
4803 {
4804 delete arg1;
4805
4806 if (PyErr_Occurred()) SWIG_fail;
4807 }
4808 resultobj = SWIG_Py_Void();
4809 return resultobj;
4810 fail:
4811 return NULL;
4812 }
4813
4814
4815 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4816 PyObject *resultobj = 0;
4817 wxSize *arg1 = (wxSize *) 0 ;
4818 PyObject *arg2 = (PyObject *) 0 ;
4819 bool result;
4820 void *argp1 = 0 ;
4821 int res1 = 0 ;
4822 PyObject * obj0 = 0 ;
4823 PyObject * obj1 = 0 ;
4824 char * kwnames[] = {
4825 (char *) "self",(char *) "other", NULL
4826 };
4827
4828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4830 if (!SWIG_IsOK(res1)) {
4831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4832 }
4833 arg1 = reinterpret_cast< wxSize * >(argp1);
4834 arg2 = obj1;
4835 {
4836 result = (bool)wxSize___eq__(arg1,arg2);
4837 if (PyErr_Occurred()) SWIG_fail;
4838 }
4839 {
4840 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4841 }
4842 return resultobj;
4843 fail:
4844 return NULL;
4845 }
4846
4847
4848 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4849 PyObject *resultobj = 0;
4850 wxSize *arg1 = (wxSize *) 0 ;
4851 PyObject *arg2 = (PyObject *) 0 ;
4852 bool result;
4853 void *argp1 = 0 ;
4854 int res1 = 0 ;
4855 PyObject * obj0 = 0 ;
4856 PyObject * obj1 = 0 ;
4857 char * kwnames[] = {
4858 (char *) "self",(char *) "other", NULL
4859 };
4860
4861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4863 if (!SWIG_IsOK(res1)) {
4864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4865 }
4866 arg1 = reinterpret_cast< wxSize * >(argp1);
4867 arg2 = obj1;
4868 {
4869 result = (bool)wxSize___ne__(arg1,arg2);
4870 if (PyErr_Occurred()) SWIG_fail;
4871 }
4872 {
4873 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4874 }
4875 return resultobj;
4876 fail:
4877 return NULL;
4878 }
4879
4880
4881 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4882 PyObject *resultobj = 0;
4883 wxSize *arg1 = (wxSize *) 0 ;
4884 wxSize *arg2 = 0 ;
4885 wxSize result;
4886 void *argp1 = 0 ;
4887 int res1 = 0 ;
4888 wxSize temp2 ;
4889 PyObject * obj0 = 0 ;
4890 PyObject * obj1 = 0 ;
4891 char * kwnames[] = {
4892 (char *) "self",(char *) "sz", NULL
4893 };
4894
4895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4897 if (!SWIG_IsOK(res1)) {
4898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4899 }
4900 arg1 = reinterpret_cast< wxSize * >(argp1);
4901 {
4902 arg2 = &temp2;
4903 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4904 }
4905 {
4906 result = (arg1)->operator +((wxSize const &)*arg2);
4907 if (PyErr_Occurred()) SWIG_fail;
4908 }
4909 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4910 return resultobj;
4911 fail:
4912 return NULL;
4913 }
4914
4915
4916 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4917 PyObject *resultobj = 0;
4918 wxSize *arg1 = (wxSize *) 0 ;
4919 wxSize *arg2 = 0 ;
4920 wxSize result;
4921 void *argp1 = 0 ;
4922 int res1 = 0 ;
4923 wxSize temp2 ;
4924 PyObject * obj0 = 0 ;
4925 PyObject * obj1 = 0 ;
4926 char * kwnames[] = {
4927 (char *) "self",(char *) "sz", NULL
4928 };
4929
4930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4932 if (!SWIG_IsOK(res1)) {
4933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4934 }
4935 arg1 = reinterpret_cast< wxSize * >(argp1);
4936 {
4937 arg2 = &temp2;
4938 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4939 }
4940 {
4941 result = (arg1)->operator -((wxSize const &)*arg2);
4942 if (PyErr_Occurred()) SWIG_fail;
4943 }
4944 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4945 return resultobj;
4946 fail:
4947 return NULL;
4948 }
4949
4950
4951 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4952 PyObject *resultobj = 0;
4953 wxSize *arg1 = (wxSize *) 0 ;
4954 wxSize *arg2 = 0 ;
4955 void *argp1 = 0 ;
4956 int res1 = 0 ;
4957 wxSize temp2 ;
4958 PyObject * obj0 = 0 ;
4959 PyObject * obj1 = 0 ;
4960 char * kwnames[] = {
4961 (char *) "self",(char *) "sz", NULL
4962 };
4963
4964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4966 if (!SWIG_IsOK(res1)) {
4967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4968 }
4969 arg1 = reinterpret_cast< wxSize * >(argp1);
4970 {
4971 arg2 = &temp2;
4972 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4973 }
4974 {
4975 (arg1)->IncTo((wxSize const &)*arg2);
4976 if (PyErr_Occurred()) SWIG_fail;
4977 }
4978 resultobj = SWIG_Py_Void();
4979 return resultobj;
4980 fail:
4981 return NULL;
4982 }
4983
4984
4985 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4986 PyObject *resultobj = 0;
4987 wxSize *arg1 = (wxSize *) 0 ;
4988 wxSize *arg2 = 0 ;
4989 void *argp1 = 0 ;
4990 int res1 = 0 ;
4991 wxSize temp2 ;
4992 PyObject * obj0 = 0 ;
4993 PyObject * obj1 = 0 ;
4994 char * kwnames[] = {
4995 (char *) "self",(char *) "sz", NULL
4996 };
4997
4998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5000 if (!SWIG_IsOK(res1)) {
5001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
5002 }
5003 arg1 = reinterpret_cast< wxSize * >(argp1);
5004 {
5005 arg2 = &temp2;
5006 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5007 }
5008 {
5009 (arg1)->DecTo((wxSize const &)*arg2);
5010 if (PyErr_Occurred()) SWIG_fail;
5011 }
5012 resultobj = SWIG_Py_Void();
5013 return resultobj;
5014 fail:
5015 return NULL;
5016 }
5017
5018
5019 SWIGINTERN PyObject *_wrap_Size_IncBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5020 PyObject *resultobj = 0;
5021 wxSize *arg1 = (wxSize *) 0 ;
5022 int arg2 ;
5023 int arg3 ;
5024 void *argp1 = 0 ;
5025 int res1 = 0 ;
5026 int val2 ;
5027 int ecode2 = 0 ;
5028 int val3 ;
5029 int ecode3 = 0 ;
5030 PyObject * obj0 = 0 ;
5031 PyObject * obj1 = 0 ;
5032 PyObject * obj2 = 0 ;
5033 char * kwnames[] = {
5034 (char *) "self",(char *) "dx",(char *) "dy", NULL
5035 };
5036
5037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_IncBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5039 if (!SWIG_IsOK(res1)) {
5040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncBy" "', expected argument " "1"" of type '" "wxSize *""'");
5041 }
5042 arg1 = reinterpret_cast< wxSize * >(argp1);
5043 ecode2 = SWIG_AsVal_int(obj1, &val2);
5044 if (!SWIG_IsOK(ecode2)) {
5045 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_IncBy" "', expected argument " "2"" of type '" "int""'");
5046 }
5047 arg2 = static_cast< int >(val2);
5048 ecode3 = SWIG_AsVal_int(obj2, &val3);
5049 if (!SWIG_IsOK(ecode3)) {
5050 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_IncBy" "', expected argument " "3"" of type '" "int""'");
5051 }
5052 arg3 = static_cast< int >(val3);
5053 {
5054 (arg1)->IncBy(arg2,arg3);
5055 if (PyErr_Occurred()) SWIG_fail;
5056 }
5057 resultobj = SWIG_Py_Void();
5058 return resultobj;
5059 fail:
5060 return NULL;
5061 }
5062
5063
5064 SWIGINTERN PyObject *_wrap_Size_DecBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5065 PyObject *resultobj = 0;
5066 wxSize *arg1 = (wxSize *) 0 ;
5067 int arg2 ;
5068 int arg3 ;
5069 void *argp1 = 0 ;
5070 int res1 = 0 ;
5071 int val2 ;
5072 int ecode2 = 0 ;
5073 int val3 ;
5074 int ecode3 = 0 ;
5075 PyObject * obj0 = 0 ;
5076 PyObject * obj1 = 0 ;
5077 PyObject * obj2 = 0 ;
5078 char * kwnames[] = {
5079 (char *) "self",(char *) "dx",(char *) "dy", NULL
5080 };
5081
5082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_DecBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5084 if (!SWIG_IsOK(res1)) {
5085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecBy" "', expected argument " "1"" of type '" "wxSize *""'");
5086 }
5087 arg1 = reinterpret_cast< wxSize * >(argp1);
5088 ecode2 = SWIG_AsVal_int(obj1, &val2);
5089 if (!SWIG_IsOK(ecode2)) {
5090 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_DecBy" "', expected argument " "2"" of type '" "int""'");
5091 }
5092 arg2 = static_cast< int >(val2);
5093 ecode3 = SWIG_AsVal_int(obj2, &val3);
5094 if (!SWIG_IsOK(ecode3)) {
5095 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_DecBy" "', expected argument " "3"" of type '" "int""'");
5096 }
5097 arg3 = static_cast< int >(val3);
5098 {
5099 (arg1)->DecBy(arg2,arg3);
5100 if (PyErr_Occurred()) SWIG_fail;
5101 }
5102 resultobj = SWIG_Py_Void();
5103 return resultobj;
5104 fail:
5105 return NULL;
5106 }
5107
5108
5109 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5110 PyObject *resultobj = 0;
5111 wxSize *arg1 = (wxSize *) 0 ;
5112 float arg2 ;
5113 float arg3 ;
5114 void *argp1 = 0 ;
5115 int res1 = 0 ;
5116 float val2 ;
5117 int ecode2 = 0 ;
5118 float val3 ;
5119 int ecode3 = 0 ;
5120 PyObject * obj0 = 0 ;
5121 PyObject * obj1 = 0 ;
5122 PyObject * obj2 = 0 ;
5123 char * kwnames[] = {
5124 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
5125 };
5126
5127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5129 if (!SWIG_IsOK(res1)) {
5130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
5131 }
5132 arg1 = reinterpret_cast< wxSize * >(argp1);
5133 ecode2 = SWIG_AsVal_float(obj1, &val2);
5134 if (!SWIG_IsOK(ecode2)) {
5135 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
5136 }
5137 arg2 = static_cast< float >(val2);
5138 ecode3 = SWIG_AsVal_float(obj2, &val3);
5139 if (!SWIG_IsOK(ecode3)) {
5140 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
5141 }
5142 arg3 = static_cast< float >(val3);
5143 {
5144 (arg1)->Scale(arg2,arg3);
5145 if (PyErr_Occurred()) SWIG_fail;
5146 }
5147 resultobj = SWIG_Py_Void();
5148 return resultobj;
5149 fail:
5150 return NULL;
5151 }
5152
5153
5154 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5155 PyObject *resultobj = 0;
5156 wxSize *arg1 = (wxSize *) 0 ;
5157 int arg2 ;
5158 int arg3 ;
5159 void *argp1 = 0 ;
5160 int res1 = 0 ;
5161 int val2 ;
5162 int ecode2 = 0 ;
5163 int val3 ;
5164 int ecode3 = 0 ;
5165 PyObject * obj0 = 0 ;
5166 PyObject * obj1 = 0 ;
5167 PyObject * obj2 = 0 ;
5168 char * kwnames[] = {
5169 (char *) "self",(char *) "w",(char *) "h", NULL
5170 };
5171
5172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5174 if (!SWIG_IsOK(res1)) {
5175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
5176 }
5177 arg1 = reinterpret_cast< wxSize * >(argp1);
5178 ecode2 = SWIG_AsVal_int(obj1, &val2);
5179 if (!SWIG_IsOK(ecode2)) {
5180 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
5181 }
5182 arg2 = static_cast< int >(val2);
5183 ecode3 = SWIG_AsVal_int(obj2, &val3);
5184 if (!SWIG_IsOK(ecode3)) {
5185 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
5186 }
5187 arg3 = static_cast< int >(val3);
5188 {
5189 (arg1)->Set(arg2,arg3);
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_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5200 PyObject *resultobj = 0;
5201 wxSize *arg1 = (wxSize *) 0 ;
5202 int arg2 ;
5203 void *argp1 = 0 ;
5204 int res1 = 0 ;
5205 int val2 ;
5206 int ecode2 = 0 ;
5207 PyObject * obj0 = 0 ;
5208 PyObject * obj1 = 0 ;
5209 char * kwnames[] = {
5210 (char *) "self",(char *) "w", NULL
5211 };
5212
5213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
5214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5215 if (!SWIG_IsOK(res1)) {
5216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
5217 }
5218 arg1 = reinterpret_cast< wxSize * >(argp1);
5219 ecode2 = SWIG_AsVal_int(obj1, &val2);
5220 if (!SWIG_IsOK(ecode2)) {
5221 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
5222 }
5223 arg2 = static_cast< int >(val2);
5224 {
5225 (arg1)->SetWidth(arg2);
5226 if (PyErr_Occurred()) SWIG_fail;
5227 }
5228 resultobj = SWIG_Py_Void();
5229 return resultobj;
5230 fail:
5231 return NULL;
5232 }
5233
5234
5235 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5236 PyObject *resultobj = 0;
5237 wxSize *arg1 = (wxSize *) 0 ;
5238 int arg2 ;
5239 void *argp1 = 0 ;
5240 int res1 = 0 ;
5241 int val2 ;
5242 int ecode2 = 0 ;
5243 PyObject * obj0 = 0 ;
5244 PyObject * obj1 = 0 ;
5245 char * kwnames[] = {
5246 (char *) "self",(char *) "h", NULL
5247 };
5248
5249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
5250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5251 if (!SWIG_IsOK(res1)) {
5252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
5253 }
5254 arg1 = reinterpret_cast< wxSize * >(argp1);
5255 ecode2 = SWIG_AsVal_int(obj1, &val2);
5256 if (!SWIG_IsOK(ecode2)) {
5257 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5258 }
5259 arg2 = static_cast< int >(val2);
5260 {
5261 (arg1)->SetHeight(arg2);
5262 if (PyErr_Occurred()) SWIG_fail;
5263 }
5264 resultobj = SWIG_Py_Void();
5265 return resultobj;
5266 fail:
5267 return NULL;
5268 }
5269
5270
5271 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5272 PyObject *resultobj = 0;
5273 wxSize *arg1 = (wxSize *) 0 ;
5274 int result;
5275 void *argp1 = 0 ;
5276 int res1 = 0 ;
5277 PyObject *swig_obj[1] ;
5278
5279 if (!args) SWIG_fail;
5280 swig_obj[0] = args;
5281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5282 if (!SWIG_IsOK(res1)) {
5283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5284 }
5285 arg1 = reinterpret_cast< wxSize * >(argp1);
5286 {
5287 result = (int)((wxSize const *)arg1)->GetWidth();
5288 if (PyErr_Occurred()) SWIG_fail;
5289 }
5290 resultobj = SWIG_From_int(static_cast< int >(result));
5291 return resultobj;
5292 fail:
5293 return NULL;
5294 }
5295
5296
5297 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5298 PyObject *resultobj = 0;
5299 wxSize *arg1 = (wxSize *) 0 ;
5300 int result;
5301 void *argp1 = 0 ;
5302 int res1 = 0 ;
5303 PyObject *swig_obj[1] ;
5304
5305 if (!args) SWIG_fail;
5306 swig_obj[0] = args;
5307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5308 if (!SWIG_IsOK(res1)) {
5309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5310 }
5311 arg1 = reinterpret_cast< wxSize * >(argp1);
5312 {
5313 result = (int)((wxSize const *)arg1)->GetHeight();
5314 if (PyErr_Occurred()) SWIG_fail;
5315 }
5316 resultobj = SWIG_From_int(static_cast< int >(result));
5317 return resultobj;
5318 fail:
5319 return NULL;
5320 }
5321
5322
5323 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5324 PyObject *resultobj = 0;
5325 wxSize *arg1 = (wxSize *) 0 ;
5326 bool result;
5327 void *argp1 = 0 ;
5328 int res1 = 0 ;
5329 PyObject *swig_obj[1] ;
5330
5331 if (!args) SWIG_fail;
5332 swig_obj[0] = args;
5333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5334 if (!SWIG_IsOK(res1)) {
5335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5336 }
5337 arg1 = reinterpret_cast< wxSize * >(argp1);
5338 {
5339 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5340 if (PyErr_Occurred()) SWIG_fail;
5341 }
5342 {
5343 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5344 }
5345 return resultobj;
5346 fail:
5347 return NULL;
5348 }
5349
5350
5351 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5352 PyObject *resultobj = 0;
5353 wxSize *arg1 = (wxSize *) 0 ;
5354 wxSize *arg2 = 0 ;
5355 void *argp1 = 0 ;
5356 int res1 = 0 ;
5357 wxSize temp2 ;
5358 PyObject * obj0 = 0 ;
5359 PyObject * obj1 = 0 ;
5360 char * kwnames[] = {
5361 (char *) "self",(char *) "size", NULL
5362 };
5363
5364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5366 if (!SWIG_IsOK(res1)) {
5367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5368 }
5369 arg1 = reinterpret_cast< wxSize * >(argp1);
5370 {
5371 arg2 = &temp2;
5372 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5373 }
5374 {
5375 (arg1)->SetDefaults((wxSize const &)*arg2);
5376 if (PyErr_Occurred()) SWIG_fail;
5377 }
5378 resultobj = SWIG_Py_Void();
5379 return resultobj;
5380 fail:
5381 return NULL;
5382 }
5383
5384
5385 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5386 PyObject *resultobj = 0;
5387 wxSize *arg1 = (wxSize *) 0 ;
5388 PyObject *result = 0 ;
5389 void *argp1 = 0 ;
5390 int res1 = 0 ;
5391 PyObject *swig_obj[1] ;
5392
5393 if (!args) SWIG_fail;
5394 swig_obj[0] = args;
5395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5396 if (!SWIG_IsOK(res1)) {
5397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5398 }
5399 arg1 = reinterpret_cast< wxSize * >(argp1);
5400 {
5401 result = (PyObject *)wxSize_Get(arg1);
5402 if (PyErr_Occurred()) SWIG_fail;
5403 }
5404 resultobj = result;
5405 return resultobj;
5406 fail:
5407 return NULL;
5408 }
5409
5410
5411 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5412 PyObject *obj;
5413 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5414 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5415 return SWIG_Py_Void();
5416 }
5417
5418 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5419 return SWIG_Python_InitShadowInstance(args);
5420 }
5421
5422 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5423 PyObject *resultobj = 0;
5424 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5425 double arg2 ;
5426 void *argp1 = 0 ;
5427 int res1 = 0 ;
5428 double val2 ;
5429 int ecode2 = 0 ;
5430 PyObject *swig_obj[2] ;
5431
5432 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5433 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5434 if (!SWIG_IsOK(res1)) {
5435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5436 }
5437 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5438 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5439 if (!SWIG_IsOK(ecode2)) {
5440 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5441 }
5442 arg2 = static_cast< double >(val2);
5443 if (arg1) (arg1)->x = arg2;
5444
5445 resultobj = SWIG_Py_Void();
5446 return resultobj;
5447 fail:
5448 return NULL;
5449 }
5450
5451
5452 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5453 PyObject *resultobj = 0;
5454 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5455 double result;
5456 void *argp1 = 0 ;
5457 int res1 = 0 ;
5458 PyObject *swig_obj[1] ;
5459
5460 if (!args) SWIG_fail;
5461 swig_obj[0] = args;
5462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5463 if (!SWIG_IsOK(res1)) {
5464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5465 }
5466 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5467 result = (double) ((arg1)->x);
5468 resultobj = SWIG_From_double(static_cast< double >(result));
5469 return resultobj;
5470 fail:
5471 return NULL;
5472 }
5473
5474
5475 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5476 PyObject *resultobj = 0;
5477 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5478 double arg2 ;
5479 void *argp1 = 0 ;
5480 int res1 = 0 ;
5481 double val2 ;
5482 int ecode2 = 0 ;
5483 PyObject *swig_obj[2] ;
5484
5485 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5487 if (!SWIG_IsOK(res1)) {
5488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5489 }
5490 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5491 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5492 if (!SWIG_IsOK(ecode2)) {
5493 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5494 }
5495 arg2 = static_cast< double >(val2);
5496 if (arg1) (arg1)->y = arg2;
5497
5498 resultobj = SWIG_Py_Void();
5499 return resultobj;
5500 fail:
5501 return NULL;
5502 }
5503
5504
5505 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5506 PyObject *resultobj = 0;
5507 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5508 double result;
5509 void *argp1 = 0 ;
5510 int res1 = 0 ;
5511 PyObject *swig_obj[1] ;
5512
5513 if (!args) SWIG_fail;
5514 swig_obj[0] = args;
5515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5516 if (!SWIG_IsOK(res1)) {
5517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5518 }
5519 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5520 result = (double) ((arg1)->y);
5521 resultobj = SWIG_From_double(static_cast< double >(result));
5522 return resultobj;
5523 fail:
5524 return NULL;
5525 }
5526
5527
5528 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5529 PyObject *resultobj = 0;
5530 double arg1 = (double) 0.0 ;
5531 double arg2 = (double) 0.0 ;
5532 wxRealPoint *result = 0 ;
5533 double val1 ;
5534 int ecode1 = 0 ;
5535 double val2 ;
5536 int ecode2 = 0 ;
5537 PyObject * obj0 = 0 ;
5538 PyObject * obj1 = 0 ;
5539 char * kwnames[] = {
5540 (char *) "x",(char *) "y", NULL
5541 };
5542
5543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5544 if (obj0) {
5545 ecode1 = SWIG_AsVal_double(obj0, &val1);
5546 if (!SWIG_IsOK(ecode1)) {
5547 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5548 }
5549 arg1 = static_cast< double >(val1);
5550 }
5551 if (obj1) {
5552 ecode2 = SWIG_AsVal_double(obj1, &val2);
5553 if (!SWIG_IsOK(ecode2)) {
5554 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5555 }
5556 arg2 = static_cast< double >(val2);
5557 }
5558 {
5559 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5560 if (PyErr_Occurred()) SWIG_fail;
5561 }
5562 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5563 return resultobj;
5564 fail:
5565 return NULL;
5566 }
5567
5568
5569 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5570 PyObject *resultobj = 0;
5571 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5572 void *argp1 = 0 ;
5573 int res1 = 0 ;
5574 PyObject *swig_obj[1] ;
5575
5576 if (!args) SWIG_fail;
5577 swig_obj[0] = args;
5578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5579 if (!SWIG_IsOK(res1)) {
5580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5581 }
5582 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5583 {
5584 delete arg1;
5585
5586 if (PyErr_Occurred()) SWIG_fail;
5587 }
5588 resultobj = SWIG_Py_Void();
5589 return resultobj;
5590 fail:
5591 return NULL;
5592 }
5593
5594
5595 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5596 PyObject *resultobj = 0;
5597 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5598 PyObject *arg2 = (PyObject *) 0 ;
5599 bool result;
5600 void *argp1 = 0 ;
5601 int res1 = 0 ;
5602 PyObject * obj0 = 0 ;
5603 PyObject * obj1 = 0 ;
5604 char * kwnames[] = {
5605 (char *) "self",(char *) "other", NULL
5606 };
5607
5608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5610 if (!SWIG_IsOK(res1)) {
5611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5612 }
5613 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5614 arg2 = obj1;
5615 {
5616 result = (bool)wxRealPoint___eq__(arg1,arg2);
5617 if (PyErr_Occurred()) SWIG_fail;
5618 }
5619 {
5620 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5621 }
5622 return resultobj;
5623 fail:
5624 return NULL;
5625 }
5626
5627
5628 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5629 PyObject *resultobj = 0;
5630 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5631 PyObject *arg2 = (PyObject *) 0 ;
5632 bool result;
5633 void *argp1 = 0 ;
5634 int res1 = 0 ;
5635 PyObject * obj0 = 0 ;
5636 PyObject * obj1 = 0 ;
5637 char * kwnames[] = {
5638 (char *) "self",(char *) "other", NULL
5639 };
5640
5641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5643 if (!SWIG_IsOK(res1)) {
5644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5645 }
5646 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5647 arg2 = obj1;
5648 {
5649 result = (bool)wxRealPoint___ne__(arg1,arg2);
5650 if (PyErr_Occurred()) SWIG_fail;
5651 }
5652 {
5653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5654 }
5655 return resultobj;
5656 fail:
5657 return NULL;
5658 }
5659
5660
5661 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5662 PyObject *resultobj = 0;
5663 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5664 wxRealPoint *arg2 = 0 ;
5665 wxRealPoint result;
5666 void *argp1 = 0 ;
5667 int res1 = 0 ;
5668 wxRealPoint temp2 ;
5669 PyObject * obj0 = 0 ;
5670 PyObject * obj1 = 0 ;
5671 char * kwnames[] = {
5672 (char *) "self",(char *) "pt", NULL
5673 };
5674
5675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5677 if (!SWIG_IsOK(res1)) {
5678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5679 }
5680 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5681 {
5682 arg2 = &temp2;
5683 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5684 }
5685 {
5686 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5687 if (PyErr_Occurred()) SWIG_fail;
5688 }
5689 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5690 return resultobj;
5691 fail:
5692 return NULL;
5693 }
5694
5695
5696 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5697 PyObject *resultobj = 0;
5698 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5699 wxRealPoint *arg2 = 0 ;
5700 wxRealPoint result;
5701 void *argp1 = 0 ;
5702 int res1 = 0 ;
5703 wxRealPoint temp2 ;
5704 PyObject * obj0 = 0 ;
5705 PyObject * obj1 = 0 ;
5706 char * kwnames[] = {
5707 (char *) "self",(char *) "pt", NULL
5708 };
5709
5710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5711 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5712 if (!SWIG_IsOK(res1)) {
5713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5714 }
5715 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5716 {
5717 arg2 = &temp2;
5718 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5719 }
5720 {
5721 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5722 if (PyErr_Occurred()) SWIG_fail;
5723 }
5724 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5725 return resultobj;
5726 fail:
5727 return NULL;
5728 }
5729
5730
5731 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5732 PyObject *resultobj = 0;
5733 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5734 double arg2 ;
5735 double arg3 ;
5736 void *argp1 = 0 ;
5737 int res1 = 0 ;
5738 double val2 ;
5739 int ecode2 = 0 ;
5740 double val3 ;
5741 int ecode3 = 0 ;
5742 PyObject * obj0 = 0 ;
5743 PyObject * obj1 = 0 ;
5744 PyObject * obj2 = 0 ;
5745 char * kwnames[] = {
5746 (char *) "self",(char *) "x",(char *) "y", NULL
5747 };
5748
5749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5751 if (!SWIG_IsOK(res1)) {
5752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5753 }
5754 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5755 ecode2 = SWIG_AsVal_double(obj1, &val2);
5756 if (!SWIG_IsOK(ecode2)) {
5757 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5758 }
5759 arg2 = static_cast< double >(val2);
5760 ecode3 = SWIG_AsVal_double(obj2, &val3);
5761 if (!SWIG_IsOK(ecode3)) {
5762 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5763 }
5764 arg3 = static_cast< double >(val3);
5765 {
5766 wxRealPoint_Set(arg1,arg2,arg3);
5767 if (PyErr_Occurred()) SWIG_fail;
5768 }
5769 resultobj = SWIG_Py_Void();
5770 return resultobj;
5771 fail:
5772 return NULL;
5773 }
5774
5775
5776 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5777 PyObject *resultobj = 0;
5778 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5779 PyObject *result = 0 ;
5780 void *argp1 = 0 ;
5781 int res1 = 0 ;
5782 PyObject *swig_obj[1] ;
5783
5784 if (!args) SWIG_fail;
5785 swig_obj[0] = args;
5786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5787 if (!SWIG_IsOK(res1)) {
5788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5789 }
5790 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5791 {
5792 result = (PyObject *)wxRealPoint_Get(arg1);
5793 if (PyErr_Occurred()) SWIG_fail;
5794 }
5795 resultobj = result;
5796 return resultobj;
5797 fail:
5798 return NULL;
5799 }
5800
5801
5802 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5803 PyObject *obj;
5804 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5805 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5806 return SWIG_Py_Void();
5807 }
5808
5809 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5810 return SWIG_Python_InitShadowInstance(args);
5811 }
5812
5813 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5814 PyObject *resultobj = 0;
5815 wxPoint *arg1 = (wxPoint *) 0 ;
5816 int arg2 ;
5817 void *argp1 = 0 ;
5818 int res1 = 0 ;
5819 int val2 ;
5820 int ecode2 = 0 ;
5821 PyObject *swig_obj[2] ;
5822
5823 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5825 if (!SWIG_IsOK(res1)) {
5826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5827 }
5828 arg1 = reinterpret_cast< wxPoint * >(argp1);
5829 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5830 if (!SWIG_IsOK(ecode2)) {
5831 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5832 }
5833 arg2 = static_cast< int >(val2);
5834 if (arg1) (arg1)->x = arg2;
5835
5836 resultobj = SWIG_Py_Void();
5837 return resultobj;
5838 fail:
5839 return NULL;
5840 }
5841
5842
5843 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5844 PyObject *resultobj = 0;
5845 wxPoint *arg1 = (wxPoint *) 0 ;
5846 int result;
5847 void *argp1 = 0 ;
5848 int res1 = 0 ;
5849 PyObject *swig_obj[1] ;
5850
5851 if (!args) SWIG_fail;
5852 swig_obj[0] = args;
5853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5854 if (!SWIG_IsOK(res1)) {
5855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5856 }
5857 arg1 = reinterpret_cast< wxPoint * >(argp1);
5858 result = (int) ((arg1)->x);
5859 resultobj = SWIG_From_int(static_cast< int >(result));
5860 return resultobj;
5861 fail:
5862 return NULL;
5863 }
5864
5865
5866 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5867 PyObject *resultobj = 0;
5868 wxPoint *arg1 = (wxPoint *) 0 ;
5869 int arg2 ;
5870 void *argp1 = 0 ;
5871 int res1 = 0 ;
5872 int val2 ;
5873 int ecode2 = 0 ;
5874 PyObject *swig_obj[2] ;
5875
5876 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5878 if (!SWIG_IsOK(res1)) {
5879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5880 }
5881 arg1 = reinterpret_cast< wxPoint * >(argp1);
5882 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5883 if (!SWIG_IsOK(ecode2)) {
5884 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5885 }
5886 arg2 = static_cast< int >(val2);
5887 if (arg1) (arg1)->y = arg2;
5888
5889 resultobj = SWIG_Py_Void();
5890 return resultobj;
5891 fail:
5892 return NULL;
5893 }
5894
5895
5896 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5897 PyObject *resultobj = 0;
5898 wxPoint *arg1 = (wxPoint *) 0 ;
5899 int result;
5900 void *argp1 = 0 ;
5901 int res1 = 0 ;
5902 PyObject *swig_obj[1] ;
5903
5904 if (!args) SWIG_fail;
5905 swig_obj[0] = args;
5906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5907 if (!SWIG_IsOK(res1)) {
5908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5909 }
5910 arg1 = reinterpret_cast< wxPoint * >(argp1);
5911 result = (int) ((arg1)->y);
5912 resultobj = SWIG_From_int(static_cast< int >(result));
5913 return resultobj;
5914 fail:
5915 return NULL;
5916 }
5917
5918
5919 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5920 PyObject *resultobj = 0;
5921 int arg1 = (int) 0 ;
5922 int arg2 = (int) 0 ;
5923 wxPoint *result = 0 ;
5924 int val1 ;
5925 int ecode1 = 0 ;
5926 int val2 ;
5927 int ecode2 = 0 ;
5928 PyObject * obj0 = 0 ;
5929 PyObject * obj1 = 0 ;
5930 char * kwnames[] = {
5931 (char *) "x",(char *) "y", NULL
5932 };
5933
5934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5935 if (obj0) {
5936 ecode1 = SWIG_AsVal_int(obj0, &val1);
5937 if (!SWIG_IsOK(ecode1)) {
5938 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5939 }
5940 arg1 = static_cast< int >(val1);
5941 }
5942 if (obj1) {
5943 ecode2 = SWIG_AsVal_int(obj1, &val2);
5944 if (!SWIG_IsOK(ecode2)) {
5945 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5946 }
5947 arg2 = static_cast< int >(val2);
5948 }
5949 {
5950 result = (wxPoint *)new wxPoint(arg1,arg2);
5951 if (PyErr_Occurred()) SWIG_fail;
5952 }
5953 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5954 return resultobj;
5955 fail:
5956 return NULL;
5957 }
5958
5959
5960 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5961 PyObject *resultobj = 0;
5962 wxPoint *arg1 = (wxPoint *) 0 ;
5963 void *argp1 = 0 ;
5964 int res1 = 0 ;
5965 PyObject *swig_obj[1] ;
5966
5967 if (!args) SWIG_fail;
5968 swig_obj[0] = args;
5969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5970 if (!SWIG_IsOK(res1)) {
5971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5972 }
5973 arg1 = reinterpret_cast< wxPoint * >(argp1);
5974 {
5975 delete arg1;
5976
5977 if (PyErr_Occurred()) SWIG_fail;
5978 }
5979 resultobj = SWIG_Py_Void();
5980 return resultobj;
5981 fail:
5982 return NULL;
5983 }
5984
5985
5986 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5987 PyObject *resultobj = 0;
5988 wxPoint *arg1 = (wxPoint *) 0 ;
5989 PyObject *arg2 = (PyObject *) 0 ;
5990 bool result;
5991 void *argp1 = 0 ;
5992 int res1 = 0 ;
5993 PyObject * obj0 = 0 ;
5994 PyObject * obj1 = 0 ;
5995 char * kwnames[] = {
5996 (char *) "self",(char *) "other", NULL
5997 };
5998
5999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
6000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6001 if (!SWIG_IsOK(res1)) {
6002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
6003 }
6004 arg1 = reinterpret_cast< wxPoint * >(argp1);
6005 arg2 = obj1;
6006 {
6007 result = (bool)wxPoint___eq__(arg1,arg2);
6008 if (PyErr_Occurred()) SWIG_fail;
6009 }
6010 {
6011 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6012 }
6013 return resultobj;
6014 fail:
6015 return NULL;
6016 }
6017
6018
6019 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6020 PyObject *resultobj = 0;
6021 wxPoint *arg1 = (wxPoint *) 0 ;
6022 PyObject *arg2 = (PyObject *) 0 ;
6023 bool result;
6024 void *argp1 = 0 ;
6025 int res1 = 0 ;
6026 PyObject * obj0 = 0 ;
6027 PyObject * obj1 = 0 ;
6028 char * kwnames[] = {
6029 (char *) "self",(char *) "other", NULL
6030 };
6031
6032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
6033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6034 if (!SWIG_IsOK(res1)) {
6035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
6036 }
6037 arg1 = reinterpret_cast< wxPoint * >(argp1);
6038 arg2 = obj1;
6039 {
6040 result = (bool)wxPoint___ne__(arg1,arg2);
6041 if (PyErr_Occurred()) SWIG_fail;
6042 }
6043 {
6044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6045 }
6046 return resultobj;
6047 fail:
6048 return NULL;
6049 }
6050
6051
6052 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6053 PyObject *resultobj = 0;
6054 wxPoint *arg1 = (wxPoint *) 0 ;
6055 wxPoint *arg2 = 0 ;
6056 wxPoint result;
6057 void *argp1 = 0 ;
6058 int res1 = 0 ;
6059 wxPoint temp2 ;
6060 PyObject * obj0 = 0 ;
6061 PyObject * obj1 = 0 ;
6062 char * kwnames[] = {
6063 (char *) "self",(char *) "pt", NULL
6064 };
6065
6066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
6067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6068 if (!SWIG_IsOK(res1)) {
6069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
6070 }
6071 arg1 = reinterpret_cast< wxPoint * >(argp1);
6072 {
6073 arg2 = &temp2;
6074 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6075 }
6076 {
6077 result = (arg1)->operator +((wxPoint const &)*arg2);
6078 if (PyErr_Occurred()) SWIG_fail;
6079 }
6080 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6081 return resultobj;
6082 fail:
6083 return NULL;
6084 }
6085
6086
6087 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6088 PyObject *resultobj = 0;
6089 wxPoint *arg1 = (wxPoint *) 0 ;
6090 wxPoint *arg2 = 0 ;
6091 wxPoint result;
6092 void *argp1 = 0 ;
6093 int res1 = 0 ;
6094 wxPoint temp2 ;
6095 PyObject * obj0 = 0 ;
6096 PyObject * obj1 = 0 ;
6097 char * kwnames[] = {
6098 (char *) "self",(char *) "pt", NULL
6099 };
6100
6101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
6102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6103 if (!SWIG_IsOK(res1)) {
6104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6105 }
6106 arg1 = reinterpret_cast< wxPoint * >(argp1);
6107 {
6108 arg2 = &temp2;
6109 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6110 }
6111 {
6112 result = (arg1)->operator -((wxPoint const &)*arg2);
6113 if (PyErr_Occurred()) SWIG_fail;
6114 }
6115 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6116 return resultobj;
6117 fail:
6118 return NULL;
6119 }
6120
6121
6122 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6123 PyObject *resultobj = 0;
6124 wxPoint *arg1 = (wxPoint *) 0 ;
6125 wxPoint *arg2 = 0 ;
6126 wxPoint *result = 0 ;
6127 void *argp1 = 0 ;
6128 int res1 = 0 ;
6129 wxPoint temp2 ;
6130 PyObject * obj0 = 0 ;
6131 PyObject * obj1 = 0 ;
6132 char * kwnames[] = {
6133 (char *) "self",(char *) "pt", NULL
6134 };
6135
6136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
6137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6138 if (!SWIG_IsOK(res1)) {
6139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
6140 }
6141 arg1 = reinterpret_cast< wxPoint * >(argp1);
6142 {
6143 arg2 = &temp2;
6144 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6145 }
6146 {
6147 {
6148 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
6149 result = (wxPoint *) &_result_ref;
6150 }
6151 if (PyErr_Occurred()) SWIG_fail;
6152 }
6153 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6154 return resultobj;
6155 fail:
6156 return NULL;
6157 }
6158
6159
6160 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6161 PyObject *resultobj = 0;
6162 wxPoint *arg1 = (wxPoint *) 0 ;
6163 wxPoint *arg2 = 0 ;
6164 wxPoint *result = 0 ;
6165 void *argp1 = 0 ;
6166 int res1 = 0 ;
6167 wxPoint temp2 ;
6168 PyObject * obj0 = 0 ;
6169 PyObject * obj1 = 0 ;
6170 char * kwnames[] = {
6171 (char *) "self",(char *) "pt", NULL
6172 };
6173
6174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
6175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6176 if (!SWIG_IsOK(res1)) {
6177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6178 }
6179 arg1 = reinterpret_cast< wxPoint * >(argp1);
6180 {
6181 arg2 = &temp2;
6182 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6183 }
6184 {
6185 {
6186 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
6187 result = (wxPoint *) &_result_ref;
6188 }
6189 if (PyErr_Occurred()) SWIG_fail;
6190 }
6191 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6192 return resultobj;
6193 fail:
6194 return NULL;
6195 }
6196
6197
6198 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6199 PyObject *resultobj = 0;
6200 wxPoint *arg1 = (wxPoint *) 0 ;
6201 long arg2 ;
6202 long arg3 ;
6203 void *argp1 = 0 ;
6204 int res1 = 0 ;
6205 long val2 ;
6206 int ecode2 = 0 ;
6207 long val3 ;
6208 int ecode3 = 0 ;
6209 PyObject * obj0 = 0 ;
6210 PyObject * obj1 = 0 ;
6211 PyObject * obj2 = 0 ;
6212 char * kwnames[] = {
6213 (char *) "self",(char *) "x",(char *) "y", NULL
6214 };
6215
6216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6218 if (!SWIG_IsOK(res1)) {
6219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6220 }
6221 arg1 = reinterpret_cast< wxPoint * >(argp1);
6222 ecode2 = SWIG_AsVal_long(obj1, &val2);
6223 if (!SWIG_IsOK(ecode2)) {
6224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6225 }
6226 arg2 = static_cast< long >(val2);
6227 ecode3 = SWIG_AsVal_long(obj2, &val3);
6228 if (!SWIG_IsOK(ecode3)) {
6229 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6230 }
6231 arg3 = static_cast< long >(val3);
6232 {
6233 wxPoint_Set(arg1,arg2,arg3);
6234 if (PyErr_Occurred()) SWIG_fail;
6235 }
6236 resultobj = SWIG_Py_Void();
6237 return resultobj;
6238 fail:
6239 return NULL;
6240 }
6241
6242
6243 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6244 PyObject *resultobj = 0;
6245 wxPoint *arg1 = (wxPoint *) 0 ;
6246 PyObject *result = 0 ;
6247 void *argp1 = 0 ;
6248 int res1 = 0 ;
6249 PyObject *swig_obj[1] ;
6250
6251 if (!args) SWIG_fail;
6252 swig_obj[0] = args;
6253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6254 if (!SWIG_IsOK(res1)) {
6255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6256 }
6257 arg1 = reinterpret_cast< wxPoint * >(argp1);
6258 {
6259 result = (PyObject *)wxPoint_Get(arg1);
6260 if (PyErr_Occurred()) SWIG_fail;
6261 }
6262 resultobj = result;
6263 return resultobj;
6264 fail:
6265 return NULL;
6266 }
6267
6268
6269 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6270 PyObject *obj;
6271 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6272 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6273 return SWIG_Py_Void();
6274 }
6275
6276 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6277 return SWIG_Python_InitShadowInstance(args);
6278 }
6279
6280 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6281 PyObject *resultobj = 0;
6282 int arg1 = (int) 0 ;
6283 int arg2 = (int) 0 ;
6284 int arg3 = (int) 0 ;
6285 int arg4 = (int) 0 ;
6286 wxRect *result = 0 ;
6287 int val1 ;
6288 int ecode1 = 0 ;
6289 int val2 ;
6290 int ecode2 = 0 ;
6291 int val3 ;
6292 int ecode3 = 0 ;
6293 int val4 ;
6294 int ecode4 = 0 ;
6295 PyObject * obj0 = 0 ;
6296 PyObject * obj1 = 0 ;
6297 PyObject * obj2 = 0 ;
6298 PyObject * obj3 = 0 ;
6299 char * kwnames[] = {
6300 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6301 };
6302
6303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6304 if (obj0) {
6305 ecode1 = SWIG_AsVal_int(obj0, &val1);
6306 if (!SWIG_IsOK(ecode1)) {
6307 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6308 }
6309 arg1 = static_cast< int >(val1);
6310 }
6311 if (obj1) {
6312 ecode2 = SWIG_AsVal_int(obj1, &val2);
6313 if (!SWIG_IsOK(ecode2)) {
6314 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6315 }
6316 arg2 = static_cast< int >(val2);
6317 }
6318 if (obj2) {
6319 ecode3 = SWIG_AsVal_int(obj2, &val3);
6320 if (!SWIG_IsOK(ecode3)) {
6321 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6322 }
6323 arg3 = static_cast< int >(val3);
6324 }
6325 if (obj3) {
6326 ecode4 = SWIG_AsVal_int(obj3, &val4);
6327 if (!SWIG_IsOK(ecode4)) {
6328 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6329 }
6330 arg4 = static_cast< int >(val4);
6331 }
6332 {
6333 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6334 if (PyErr_Occurred()) SWIG_fail;
6335 }
6336 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6337 return resultobj;
6338 fail:
6339 return NULL;
6340 }
6341
6342
6343 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6344 PyObject *resultobj = 0;
6345 wxPoint *arg1 = 0 ;
6346 wxPoint *arg2 = 0 ;
6347 wxRect *result = 0 ;
6348 wxPoint temp1 ;
6349 wxPoint temp2 ;
6350 PyObject * obj0 = 0 ;
6351 PyObject * obj1 = 0 ;
6352 char * kwnames[] = {
6353 (char *) "topLeft",(char *) "bottomRight", NULL
6354 };
6355
6356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6357 {
6358 arg1 = &temp1;
6359 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6360 }
6361 {
6362 arg2 = &temp2;
6363 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6364 }
6365 {
6366 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6367 if (PyErr_Occurred()) SWIG_fail;
6368 }
6369 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6370 return resultobj;
6371 fail:
6372 return NULL;
6373 }
6374
6375
6376 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6377 PyObject *resultobj = 0;
6378 wxPoint *arg1 = 0 ;
6379 wxSize *arg2 = 0 ;
6380 wxRect *result = 0 ;
6381 wxPoint temp1 ;
6382 wxSize temp2 ;
6383 PyObject * obj0 = 0 ;
6384 PyObject * obj1 = 0 ;
6385 char * kwnames[] = {
6386 (char *) "pos",(char *) "size", NULL
6387 };
6388
6389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6390 {
6391 arg1 = &temp1;
6392 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6393 }
6394 {
6395 arg2 = &temp2;
6396 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6397 }
6398 {
6399 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6400 if (PyErr_Occurred()) SWIG_fail;
6401 }
6402 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6403 return resultobj;
6404 fail:
6405 return NULL;
6406 }
6407
6408
6409 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6410 PyObject *resultobj = 0;
6411 wxSize *arg1 = 0 ;
6412 wxRect *result = 0 ;
6413 wxSize temp1 ;
6414 PyObject * obj0 = 0 ;
6415 char * kwnames[] = {
6416 (char *) "size", NULL
6417 };
6418
6419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6420 {
6421 arg1 = &temp1;
6422 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6423 }
6424 {
6425 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6426 if (PyErr_Occurred()) SWIG_fail;
6427 }
6428 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6429 return resultobj;
6430 fail:
6431 return NULL;
6432 }
6433
6434
6435 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6436 PyObject *resultobj = 0;
6437 wxRect *arg1 = (wxRect *) 0 ;
6438 void *argp1 = 0 ;
6439 int res1 = 0 ;
6440 PyObject *swig_obj[1] ;
6441
6442 if (!args) SWIG_fail;
6443 swig_obj[0] = args;
6444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6445 if (!SWIG_IsOK(res1)) {
6446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6447 }
6448 arg1 = reinterpret_cast< wxRect * >(argp1);
6449 {
6450 delete arg1;
6451
6452 if (PyErr_Occurred()) SWIG_fail;
6453 }
6454 resultobj = SWIG_Py_Void();
6455 return resultobj;
6456 fail:
6457 return NULL;
6458 }
6459
6460
6461 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6462 PyObject *resultobj = 0;
6463 wxRect *arg1 = (wxRect *) 0 ;
6464 int result;
6465 void *argp1 = 0 ;
6466 int res1 = 0 ;
6467 PyObject *swig_obj[1] ;
6468
6469 if (!args) SWIG_fail;
6470 swig_obj[0] = args;
6471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6472 if (!SWIG_IsOK(res1)) {
6473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6474 }
6475 arg1 = reinterpret_cast< wxRect * >(argp1);
6476 {
6477 result = (int)((wxRect const *)arg1)->GetX();
6478 if (PyErr_Occurred()) SWIG_fail;
6479 }
6480 resultobj = SWIG_From_int(static_cast< int >(result));
6481 return resultobj;
6482 fail:
6483 return NULL;
6484 }
6485
6486
6487 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6488 PyObject *resultobj = 0;
6489 wxRect *arg1 = (wxRect *) 0 ;
6490 int arg2 ;
6491 void *argp1 = 0 ;
6492 int res1 = 0 ;
6493 int val2 ;
6494 int ecode2 = 0 ;
6495 PyObject * obj0 = 0 ;
6496 PyObject * obj1 = 0 ;
6497 char * kwnames[] = {
6498 (char *) "self",(char *) "x", NULL
6499 };
6500
6501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6503 if (!SWIG_IsOK(res1)) {
6504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6505 }
6506 arg1 = reinterpret_cast< wxRect * >(argp1);
6507 ecode2 = SWIG_AsVal_int(obj1, &val2);
6508 if (!SWIG_IsOK(ecode2)) {
6509 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6510 }
6511 arg2 = static_cast< int >(val2);
6512 {
6513 (arg1)->SetX(arg2);
6514 if (PyErr_Occurred()) SWIG_fail;
6515 }
6516 resultobj = SWIG_Py_Void();
6517 return resultobj;
6518 fail:
6519 return NULL;
6520 }
6521
6522
6523 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6524 PyObject *resultobj = 0;
6525 wxRect *arg1 = (wxRect *) 0 ;
6526 int result;
6527 void *argp1 = 0 ;
6528 int res1 = 0 ;
6529 PyObject *swig_obj[1] ;
6530
6531 if (!args) SWIG_fail;
6532 swig_obj[0] = args;
6533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6534 if (!SWIG_IsOK(res1)) {
6535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6536 }
6537 arg1 = reinterpret_cast< wxRect * >(argp1);
6538 {
6539 result = (int)(arg1)->GetY();
6540 if (PyErr_Occurred()) SWIG_fail;
6541 }
6542 resultobj = SWIG_From_int(static_cast< int >(result));
6543 return resultobj;
6544 fail:
6545 return NULL;
6546 }
6547
6548
6549 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6550 PyObject *resultobj = 0;
6551 wxRect *arg1 = (wxRect *) 0 ;
6552 int arg2 ;
6553 void *argp1 = 0 ;
6554 int res1 = 0 ;
6555 int val2 ;
6556 int ecode2 = 0 ;
6557 PyObject * obj0 = 0 ;
6558 PyObject * obj1 = 0 ;
6559 char * kwnames[] = {
6560 (char *) "self",(char *) "y", NULL
6561 };
6562
6563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6565 if (!SWIG_IsOK(res1)) {
6566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6567 }
6568 arg1 = reinterpret_cast< wxRect * >(argp1);
6569 ecode2 = SWIG_AsVal_int(obj1, &val2);
6570 if (!SWIG_IsOK(ecode2)) {
6571 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6572 }
6573 arg2 = static_cast< int >(val2);
6574 {
6575 (arg1)->SetY(arg2);
6576 if (PyErr_Occurred()) SWIG_fail;
6577 }
6578 resultobj = SWIG_Py_Void();
6579 return resultobj;
6580 fail:
6581 return NULL;
6582 }
6583
6584
6585 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6586 PyObject *resultobj = 0;
6587 wxRect *arg1 = (wxRect *) 0 ;
6588 int result;
6589 void *argp1 = 0 ;
6590 int res1 = 0 ;
6591 PyObject *swig_obj[1] ;
6592
6593 if (!args) SWIG_fail;
6594 swig_obj[0] = args;
6595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6596 if (!SWIG_IsOK(res1)) {
6597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6598 }
6599 arg1 = reinterpret_cast< wxRect * >(argp1);
6600 {
6601 result = (int)((wxRect const *)arg1)->GetWidth();
6602 if (PyErr_Occurred()) SWIG_fail;
6603 }
6604 resultobj = SWIG_From_int(static_cast< int >(result));
6605 return resultobj;
6606 fail:
6607 return NULL;
6608 }
6609
6610
6611 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6612 PyObject *resultobj = 0;
6613 wxRect *arg1 = (wxRect *) 0 ;
6614 int arg2 ;
6615 void *argp1 = 0 ;
6616 int res1 = 0 ;
6617 int val2 ;
6618 int ecode2 = 0 ;
6619 PyObject * obj0 = 0 ;
6620 PyObject * obj1 = 0 ;
6621 char * kwnames[] = {
6622 (char *) "self",(char *) "w", NULL
6623 };
6624
6625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6627 if (!SWIG_IsOK(res1)) {
6628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6629 }
6630 arg1 = reinterpret_cast< wxRect * >(argp1);
6631 ecode2 = SWIG_AsVal_int(obj1, &val2);
6632 if (!SWIG_IsOK(ecode2)) {
6633 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6634 }
6635 arg2 = static_cast< int >(val2);
6636 {
6637 (arg1)->SetWidth(arg2);
6638 if (PyErr_Occurred()) SWIG_fail;
6639 }
6640 resultobj = SWIG_Py_Void();
6641 return resultobj;
6642 fail:
6643 return NULL;
6644 }
6645
6646
6647 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6648 PyObject *resultobj = 0;
6649 wxRect *arg1 = (wxRect *) 0 ;
6650 int result;
6651 void *argp1 = 0 ;
6652 int res1 = 0 ;
6653 PyObject *swig_obj[1] ;
6654
6655 if (!args) SWIG_fail;
6656 swig_obj[0] = args;
6657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6658 if (!SWIG_IsOK(res1)) {
6659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6660 }
6661 arg1 = reinterpret_cast< wxRect * >(argp1);
6662 {
6663 result = (int)((wxRect const *)arg1)->GetHeight();
6664 if (PyErr_Occurred()) SWIG_fail;
6665 }
6666 resultobj = SWIG_From_int(static_cast< int >(result));
6667 return resultobj;
6668 fail:
6669 return NULL;
6670 }
6671
6672
6673 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6674 PyObject *resultobj = 0;
6675 wxRect *arg1 = (wxRect *) 0 ;
6676 int arg2 ;
6677 void *argp1 = 0 ;
6678 int res1 = 0 ;
6679 int val2 ;
6680 int ecode2 = 0 ;
6681 PyObject * obj0 = 0 ;
6682 PyObject * obj1 = 0 ;
6683 char * kwnames[] = {
6684 (char *) "self",(char *) "h", NULL
6685 };
6686
6687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6689 if (!SWIG_IsOK(res1)) {
6690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6691 }
6692 arg1 = reinterpret_cast< wxRect * >(argp1);
6693 ecode2 = SWIG_AsVal_int(obj1, &val2);
6694 if (!SWIG_IsOK(ecode2)) {
6695 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6696 }
6697 arg2 = static_cast< int >(val2);
6698 {
6699 (arg1)->SetHeight(arg2);
6700 if (PyErr_Occurred()) SWIG_fail;
6701 }
6702 resultobj = SWIG_Py_Void();
6703 return resultobj;
6704 fail:
6705 return NULL;
6706 }
6707
6708
6709 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6710 PyObject *resultobj = 0;
6711 wxRect *arg1 = (wxRect *) 0 ;
6712 wxPoint result;
6713 void *argp1 = 0 ;
6714 int res1 = 0 ;
6715 PyObject *swig_obj[1] ;
6716
6717 if (!args) SWIG_fail;
6718 swig_obj[0] = args;
6719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6720 if (!SWIG_IsOK(res1)) {
6721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6722 }
6723 arg1 = reinterpret_cast< wxRect * >(argp1);
6724 {
6725 result = ((wxRect const *)arg1)->GetPosition();
6726 if (PyErr_Occurred()) SWIG_fail;
6727 }
6728 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6729 return resultobj;
6730 fail:
6731 return NULL;
6732 }
6733
6734
6735 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6736 PyObject *resultobj = 0;
6737 wxRect *arg1 = (wxRect *) 0 ;
6738 wxPoint *arg2 = 0 ;
6739 void *argp1 = 0 ;
6740 int res1 = 0 ;
6741 wxPoint temp2 ;
6742 PyObject * obj0 = 0 ;
6743 PyObject * obj1 = 0 ;
6744 char * kwnames[] = {
6745 (char *) "self",(char *) "p", NULL
6746 };
6747
6748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6750 if (!SWIG_IsOK(res1)) {
6751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6752 }
6753 arg1 = reinterpret_cast< wxRect * >(argp1);
6754 {
6755 arg2 = &temp2;
6756 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6757 }
6758 {
6759 (arg1)->SetPosition((wxPoint const &)*arg2);
6760 if (PyErr_Occurred()) SWIG_fail;
6761 }
6762 resultobj = SWIG_Py_Void();
6763 return resultobj;
6764 fail:
6765 return NULL;
6766 }
6767
6768
6769 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6770 PyObject *resultobj = 0;
6771 wxRect *arg1 = (wxRect *) 0 ;
6772 wxSize result;
6773 void *argp1 = 0 ;
6774 int res1 = 0 ;
6775 PyObject *swig_obj[1] ;
6776
6777 if (!args) SWIG_fail;
6778 swig_obj[0] = args;
6779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6780 if (!SWIG_IsOK(res1)) {
6781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6782 }
6783 arg1 = reinterpret_cast< wxRect * >(argp1);
6784 {
6785 result = ((wxRect const *)arg1)->GetSize();
6786 if (PyErr_Occurred()) SWIG_fail;
6787 }
6788 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6789 return resultobj;
6790 fail:
6791 return NULL;
6792 }
6793
6794
6795 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6796 PyObject *resultobj = 0;
6797 wxRect *arg1 = (wxRect *) 0 ;
6798 wxSize *arg2 = 0 ;
6799 void *argp1 = 0 ;
6800 int res1 = 0 ;
6801 wxSize temp2 ;
6802 PyObject * obj0 = 0 ;
6803 PyObject * obj1 = 0 ;
6804 char * kwnames[] = {
6805 (char *) "self",(char *) "s", NULL
6806 };
6807
6808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6810 if (!SWIG_IsOK(res1)) {
6811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6812 }
6813 arg1 = reinterpret_cast< wxRect * >(argp1);
6814 {
6815 arg2 = &temp2;
6816 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6817 }
6818 {
6819 (arg1)->SetSize((wxSize const &)*arg2);
6820 if (PyErr_Occurred()) SWIG_fail;
6821 }
6822 resultobj = SWIG_Py_Void();
6823 return resultobj;
6824 fail:
6825 return NULL;
6826 }
6827
6828
6829 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6830 PyObject *resultobj = 0;
6831 wxRect *arg1 = (wxRect *) 0 ;
6832 bool result;
6833 void *argp1 = 0 ;
6834 int res1 = 0 ;
6835 PyObject *swig_obj[1] ;
6836
6837 if (!args) SWIG_fail;
6838 swig_obj[0] = args;
6839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6840 if (!SWIG_IsOK(res1)) {
6841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6842 }
6843 arg1 = reinterpret_cast< wxRect * >(argp1);
6844 {
6845 result = (bool)((wxRect const *)arg1)->IsEmpty();
6846 if (PyErr_Occurred()) SWIG_fail;
6847 }
6848 {
6849 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6850 }
6851 return resultobj;
6852 fail:
6853 return NULL;
6854 }
6855
6856
6857 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6858 PyObject *resultobj = 0;
6859 wxRect *arg1 = (wxRect *) 0 ;
6860 wxPoint result;
6861 void *argp1 = 0 ;
6862 int res1 = 0 ;
6863 PyObject *swig_obj[1] ;
6864
6865 if (!args) SWIG_fail;
6866 swig_obj[0] = args;
6867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6868 if (!SWIG_IsOK(res1)) {
6869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6870 }
6871 arg1 = reinterpret_cast< wxRect * >(argp1);
6872 {
6873 result = ((wxRect const *)arg1)->GetTopLeft();
6874 if (PyErr_Occurred()) SWIG_fail;
6875 }
6876 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6877 return resultobj;
6878 fail:
6879 return NULL;
6880 }
6881
6882
6883 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6884 PyObject *resultobj = 0;
6885 wxRect *arg1 = (wxRect *) 0 ;
6886 wxPoint *arg2 = 0 ;
6887 void *argp1 = 0 ;
6888 int res1 = 0 ;
6889 wxPoint temp2 ;
6890 PyObject * obj0 = 0 ;
6891 PyObject * obj1 = 0 ;
6892 char * kwnames[] = {
6893 (char *) "self",(char *) "p", NULL
6894 };
6895
6896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6898 if (!SWIG_IsOK(res1)) {
6899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6900 }
6901 arg1 = reinterpret_cast< wxRect * >(argp1);
6902 {
6903 arg2 = &temp2;
6904 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6905 }
6906 {
6907 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6908 if (PyErr_Occurred()) SWIG_fail;
6909 }
6910 resultobj = SWIG_Py_Void();
6911 return resultobj;
6912 fail:
6913 return NULL;
6914 }
6915
6916
6917 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6918 PyObject *resultobj = 0;
6919 wxRect *arg1 = (wxRect *) 0 ;
6920 wxPoint result;
6921 void *argp1 = 0 ;
6922 int res1 = 0 ;
6923 PyObject *swig_obj[1] ;
6924
6925 if (!args) SWIG_fail;
6926 swig_obj[0] = args;
6927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6928 if (!SWIG_IsOK(res1)) {
6929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6930 }
6931 arg1 = reinterpret_cast< wxRect * >(argp1);
6932 {
6933 result = ((wxRect const *)arg1)->GetBottomRight();
6934 if (PyErr_Occurred()) SWIG_fail;
6935 }
6936 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6937 return resultobj;
6938 fail:
6939 return NULL;
6940 }
6941
6942
6943 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6944 PyObject *resultobj = 0;
6945 wxRect *arg1 = (wxRect *) 0 ;
6946 wxPoint *arg2 = 0 ;
6947 void *argp1 = 0 ;
6948 int res1 = 0 ;
6949 wxPoint temp2 ;
6950 PyObject * obj0 = 0 ;
6951 PyObject * obj1 = 0 ;
6952 char * kwnames[] = {
6953 (char *) "self",(char *) "p", NULL
6954 };
6955
6956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6958 if (!SWIG_IsOK(res1)) {
6959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6960 }
6961 arg1 = reinterpret_cast< wxRect * >(argp1);
6962 {
6963 arg2 = &temp2;
6964 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6965 }
6966 {
6967 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6968 if (PyErr_Occurred()) SWIG_fail;
6969 }
6970 resultobj = SWIG_Py_Void();
6971 return resultobj;
6972 fail:
6973 return NULL;
6974 }
6975
6976
6977 SWIGINTERN PyObject *_wrap_Rect_GetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6978 PyObject *resultobj = 0;
6979 wxRect *arg1 = (wxRect *) 0 ;
6980 wxPoint result;
6981 void *argp1 = 0 ;
6982 int res1 = 0 ;
6983 PyObject *swig_obj[1] ;
6984
6985 if (!args) SWIG_fail;
6986 swig_obj[0] = args;
6987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6988 if (!SWIG_IsOK(res1)) {
6989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6990 }
6991 arg1 = reinterpret_cast< wxRect * >(argp1);
6992 {
6993 result = ((wxRect const *)arg1)->GetTopRight();
6994 if (PyErr_Occurred()) SWIG_fail;
6995 }
6996 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6997 return resultobj;
6998 fail:
6999 return NULL;
7000 }
7001
7002
7003 SWIGINTERN PyObject *_wrap_Rect_SetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7004 PyObject *resultobj = 0;
7005 wxRect *arg1 = (wxRect *) 0 ;
7006 wxPoint *arg2 = 0 ;
7007 void *argp1 = 0 ;
7008 int res1 = 0 ;
7009 wxPoint temp2 ;
7010 PyObject * obj0 = 0 ;
7011 PyObject * obj1 = 0 ;
7012 char * kwnames[] = {
7013 (char *) "self",(char *) "p", NULL
7014 };
7015
7016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopRight",kwnames,&obj0,&obj1)) SWIG_fail;
7017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7018 if (!SWIG_IsOK(res1)) {
7019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopRight" "', expected argument " "1"" of type '" "wxRect *""'");
7020 }
7021 arg1 = reinterpret_cast< wxRect * >(argp1);
7022 {
7023 arg2 = &temp2;
7024 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7025 }
7026 {
7027 (arg1)->SetTopRight((wxPoint const &)*arg2);
7028 if (PyErr_Occurred()) SWIG_fail;
7029 }
7030 resultobj = SWIG_Py_Void();
7031 return resultobj;
7032 fail:
7033 return NULL;
7034 }
7035
7036
7037 SWIGINTERN PyObject *_wrap_Rect_GetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7038 PyObject *resultobj = 0;
7039 wxRect *arg1 = (wxRect *) 0 ;
7040 wxPoint result;
7041 void *argp1 = 0 ;
7042 int res1 = 0 ;
7043 PyObject *swig_obj[1] ;
7044
7045 if (!args) SWIG_fail;
7046 swig_obj[0] = args;
7047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7048 if (!SWIG_IsOK(res1)) {
7049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
7050 }
7051 arg1 = reinterpret_cast< wxRect * >(argp1);
7052 {
7053 result = ((wxRect const *)arg1)->GetBottomLeft();
7054 if (PyErr_Occurred()) SWIG_fail;
7055 }
7056 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
7057 return resultobj;
7058 fail:
7059 return NULL;
7060 }
7061
7062
7063 SWIGINTERN PyObject *_wrap_Rect_SetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7064 PyObject *resultobj = 0;
7065 wxRect *arg1 = (wxRect *) 0 ;
7066 wxPoint *arg2 = 0 ;
7067 void *argp1 = 0 ;
7068 int res1 = 0 ;
7069 wxPoint temp2 ;
7070 PyObject * obj0 = 0 ;
7071 PyObject * obj1 = 0 ;
7072 char * kwnames[] = {
7073 (char *) "self",(char *) "p", NULL
7074 };
7075
7076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7078 if (!SWIG_IsOK(res1)) {
7079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7080 }
7081 arg1 = reinterpret_cast< wxRect * >(argp1);
7082 {
7083 arg2 = &temp2;
7084 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7085 }
7086 {
7087 (arg1)->SetBottomLeft((wxPoint const &)*arg2);
7088 if (PyErr_Occurred()) SWIG_fail;
7089 }
7090 resultobj = SWIG_Py_Void();
7091 return resultobj;
7092 fail:
7093 return NULL;
7094 }
7095
7096
7097 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7098 PyObject *resultobj = 0;
7099 wxRect *arg1 = (wxRect *) 0 ;
7100 int result;
7101 void *argp1 = 0 ;
7102 int res1 = 0 ;
7103 PyObject *swig_obj[1] ;
7104
7105 if (!args) SWIG_fail;
7106 swig_obj[0] = args;
7107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7108 if (!SWIG_IsOK(res1)) {
7109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
7110 }
7111 arg1 = reinterpret_cast< wxRect * >(argp1);
7112 {
7113 result = (int)((wxRect const *)arg1)->GetLeft();
7114 if (PyErr_Occurred()) SWIG_fail;
7115 }
7116 resultobj = SWIG_From_int(static_cast< int >(result));
7117 return resultobj;
7118 fail:
7119 return NULL;
7120 }
7121
7122
7123 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7124 PyObject *resultobj = 0;
7125 wxRect *arg1 = (wxRect *) 0 ;
7126 int result;
7127 void *argp1 = 0 ;
7128 int res1 = 0 ;
7129 PyObject *swig_obj[1] ;
7130
7131 if (!args) SWIG_fail;
7132 swig_obj[0] = args;
7133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7134 if (!SWIG_IsOK(res1)) {
7135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
7136 }
7137 arg1 = reinterpret_cast< wxRect * >(argp1);
7138 {
7139 result = (int)((wxRect const *)arg1)->GetTop();
7140 if (PyErr_Occurred()) SWIG_fail;
7141 }
7142 resultobj = SWIG_From_int(static_cast< int >(result));
7143 return resultobj;
7144 fail:
7145 return NULL;
7146 }
7147
7148
7149 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7150 PyObject *resultobj = 0;
7151 wxRect *arg1 = (wxRect *) 0 ;
7152 int result;
7153 void *argp1 = 0 ;
7154 int res1 = 0 ;
7155 PyObject *swig_obj[1] ;
7156
7157 if (!args) SWIG_fail;
7158 swig_obj[0] = args;
7159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7160 if (!SWIG_IsOK(res1)) {
7161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
7162 }
7163 arg1 = reinterpret_cast< wxRect * >(argp1);
7164 {
7165 result = (int)((wxRect const *)arg1)->GetBottom();
7166 if (PyErr_Occurred()) SWIG_fail;
7167 }
7168 resultobj = SWIG_From_int(static_cast< int >(result));
7169 return resultobj;
7170 fail:
7171 return NULL;
7172 }
7173
7174
7175 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7176 PyObject *resultobj = 0;
7177 wxRect *arg1 = (wxRect *) 0 ;
7178 int result;
7179 void *argp1 = 0 ;
7180 int res1 = 0 ;
7181 PyObject *swig_obj[1] ;
7182
7183 if (!args) SWIG_fail;
7184 swig_obj[0] = args;
7185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7186 if (!SWIG_IsOK(res1)) {
7187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
7188 }
7189 arg1 = reinterpret_cast< wxRect * >(argp1);
7190 {
7191 result = (int)((wxRect const *)arg1)->GetRight();
7192 if (PyErr_Occurred()) SWIG_fail;
7193 }
7194 resultobj = SWIG_From_int(static_cast< int >(result));
7195 return resultobj;
7196 fail:
7197 return NULL;
7198 }
7199
7200
7201 SWIGINTERN PyObject *_wrap_Rect_SetLeft(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 *) "left", NULL
7213 };
7214
7215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",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_SetLeft" "', 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_SetLeft" "', expected argument " "2"" of type '" "int""'");
7224 }
7225 arg2 = static_cast< int >(val2);
7226 {
7227 (arg1)->SetLeft(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_SetRight(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 *) "right", NULL
7249 };
7250
7251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",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_SetRight" "', 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_SetRight" "', expected argument " "2"" of type '" "int""'");
7260 }
7261 arg2 = static_cast< int >(val2);
7262 {
7263 (arg1)->SetRight(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_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7274 PyObject *resultobj = 0;
7275 wxRect *arg1 = (wxRect *) 0 ;
7276 int arg2 ;
7277 void *argp1 = 0 ;
7278 int res1 = 0 ;
7279 int val2 ;
7280 int ecode2 = 0 ;
7281 PyObject * obj0 = 0 ;
7282 PyObject * obj1 = 0 ;
7283 char * kwnames[] = {
7284 (char *) "self",(char *) "top", NULL
7285 };
7286
7287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7289 if (!SWIG_IsOK(res1)) {
7290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7291 }
7292 arg1 = reinterpret_cast< wxRect * >(argp1);
7293 ecode2 = SWIG_AsVal_int(obj1, &val2);
7294 if (!SWIG_IsOK(ecode2)) {
7295 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7296 }
7297 arg2 = static_cast< int >(val2);
7298 {
7299 (arg1)->SetTop(arg2);
7300 if (PyErr_Occurred()) SWIG_fail;
7301 }
7302 resultobj = SWIG_Py_Void();
7303 return resultobj;
7304 fail:
7305 return NULL;
7306 }
7307
7308
7309 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7310 PyObject *resultobj = 0;
7311 wxRect *arg1 = (wxRect *) 0 ;
7312 int arg2 ;
7313 void *argp1 = 0 ;
7314 int res1 = 0 ;
7315 int val2 ;
7316 int ecode2 = 0 ;
7317 PyObject * obj0 = 0 ;
7318 PyObject * obj1 = 0 ;
7319 char * kwnames[] = {
7320 (char *) "self",(char *) "bottom", NULL
7321 };
7322
7323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7324 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7325 if (!SWIG_IsOK(res1)) {
7326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7327 }
7328 arg1 = reinterpret_cast< wxRect * >(argp1);
7329 ecode2 = SWIG_AsVal_int(obj1, &val2);
7330 if (!SWIG_IsOK(ecode2)) {
7331 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7332 }
7333 arg2 = static_cast< int >(val2);
7334 {
7335 (arg1)->SetBottom(arg2);
7336 if (PyErr_Occurred()) SWIG_fail;
7337 }
7338 resultobj = SWIG_Py_Void();
7339 return resultobj;
7340 fail:
7341 return NULL;
7342 }
7343
7344
7345 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7346 PyObject *resultobj = 0;
7347 wxRect *arg1 = (wxRect *) 0 ;
7348 int arg2 ;
7349 int arg3 ;
7350 wxRect result;
7351 void *argp1 = 0 ;
7352 int res1 = 0 ;
7353 int val2 ;
7354 int ecode2 = 0 ;
7355 int val3 ;
7356 int ecode3 = 0 ;
7357 PyObject * obj0 = 0 ;
7358 PyObject * obj1 = 0 ;
7359 PyObject * obj2 = 0 ;
7360 char * kwnames[] = {
7361 (char *) "self",(char *) "dx",(char *) "dy", NULL
7362 };
7363
7364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7366 if (!SWIG_IsOK(res1)) {
7367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7368 }
7369 arg1 = reinterpret_cast< wxRect * >(argp1);
7370 ecode2 = SWIG_AsVal_int(obj1, &val2);
7371 if (!SWIG_IsOK(ecode2)) {
7372 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7373 }
7374 arg2 = static_cast< int >(val2);
7375 ecode3 = SWIG_AsVal_int(obj2, &val3);
7376 if (!SWIG_IsOK(ecode3)) {
7377 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7378 }
7379 arg3 = static_cast< int >(val3);
7380 {
7381 result = (arg1)->Inflate(arg2,arg3);
7382 if (PyErr_Occurred()) SWIG_fail;
7383 }
7384 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7385 return resultobj;
7386 fail:
7387 return NULL;
7388 }
7389
7390
7391 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7392 PyObject *resultobj = 0;
7393 wxRect *arg1 = (wxRect *) 0 ;
7394 int arg2 ;
7395 int arg3 ;
7396 wxRect *result = 0 ;
7397 void *argp1 = 0 ;
7398 int res1 = 0 ;
7399 int val2 ;
7400 int ecode2 = 0 ;
7401 int val3 ;
7402 int ecode3 = 0 ;
7403 PyObject * obj0 = 0 ;
7404 PyObject * obj1 = 0 ;
7405 PyObject * obj2 = 0 ;
7406 char * kwnames[] = {
7407 (char *) "self",(char *) "dx",(char *) "dy", NULL
7408 };
7409
7410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7412 if (!SWIG_IsOK(res1)) {
7413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7414 }
7415 arg1 = reinterpret_cast< wxRect * >(argp1);
7416 ecode2 = SWIG_AsVal_int(obj1, &val2);
7417 if (!SWIG_IsOK(ecode2)) {
7418 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7419 }
7420 arg2 = static_cast< int >(val2);
7421 ecode3 = SWIG_AsVal_int(obj2, &val3);
7422 if (!SWIG_IsOK(ecode3)) {
7423 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7424 }
7425 arg3 = static_cast< int >(val3);
7426 {
7427 {
7428 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7429 result = (wxRect *) &_result_ref;
7430 }
7431 if (PyErr_Occurred()) SWIG_fail;
7432 }
7433 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7434 return resultobj;
7435 fail:
7436 return NULL;
7437 }
7438
7439
7440 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7441 PyObject *resultobj = 0;
7442 wxRect *arg1 = (wxRect *) 0 ;
7443 int arg2 ;
7444 int arg3 ;
7445 void *argp1 = 0 ;
7446 int res1 = 0 ;
7447 int val2 ;
7448 int ecode2 = 0 ;
7449 int val3 ;
7450 int ecode3 = 0 ;
7451 PyObject * obj0 = 0 ;
7452 PyObject * obj1 = 0 ;
7453 PyObject * obj2 = 0 ;
7454 char * kwnames[] = {
7455 (char *) "self",(char *) "dx",(char *) "dy", NULL
7456 };
7457
7458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7460 if (!SWIG_IsOK(res1)) {
7461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7462 }
7463 arg1 = reinterpret_cast< wxRect * >(argp1);
7464 ecode2 = SWIG_AsVal_int(obj1, &val2);
7465 if (!SWIG_IsOK(ecode2)) {
7466 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7467 }
7468 arg2 = static_cast< int >(val2);
7469 ecode3 = SWIG_AsVal_int(obj2, &val3);
7470 if (!SWIG_IsOK(ecode3)) {
7471 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7472 }
7473 arg3 = static_cast< int >(val3);
7474 {
7475 (arg1)->Offset(arg2,arg3);
7476 if (PyErr_Occurred()) SWIG_fail;
7477 }
7478 resultobj = SWIG_Py_Void();
7479 return resultobj;
7480 fail:
7481 return NULL;
7482 }
7483
7484
7485 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7486 PyObject *resultobj = 0;
7487 wxRect *arg1 = (wxRect *) 0 ;
7488 wxPoint *arg2 = 0 ;
7489 void *argp1 = 0 ;
7490 int res1 = 0 ;
7491 wxPoint temp2 ;
7492 PyObject * obj0 = 0 ;
7493 PyObject * obj1 = 0 ;
7494 char * kwnames[] = {
7495 (char *) "self",(char *) "pt", NULL
7496 };
7497
7498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7500 if (!SWIG_IsOK(res1)) {
7501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7502 }
7503 arg1 = reinterpret_cast< wxRect * >(argp1);
7504 {
7505 arg2 = &temp2;
7506 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7507 }
7508 {
7509 (arg1)->Offset((wxPoint const &)*arg2);
7510 if (PyErr_Occurred()) SWIG_fail;
7511 }
7512 resultobj = SWIG_Py_Void();
7513 return resultobj;
7514 fail:
7515 return NULL;
7516 }
7517
7518
7519 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7520 PyObject *resultobj = 0;
7521 wxRect *arg1 = (wxRect *) 0 ;
7522 wxRect *arg2 = 0 ;
7523 wxRect result;
7524 void *argp1 = 0 ;
7525 int res1 = 0 ;
7526 wxRect temp2 ;
7527 PyObject * obj0 = 0 ;
7528 PyObject * obj1 = 0 ;
7529 char * kwnames[] = {
7530 (char *) "self",(char *) "rect", NULL
7531 };
7532
7533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7535 if (!SWIG_IsOK(res1)) {
7536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7537 }
7538 arg1 = reinterpret_cast< wxRect * >(argp1);
7539 {
7540 arg2 = &temp2;
7541 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7542 }
7543 {
7544 result = (arg1)->Intersect((wxRect const &)*arg2);
7545 if (PyErr_Occurred()) SWIG_fail;
7546 }
7547 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7548 return resultobj;
7549 fail:
7550 return NULL;
7551 }
7552
7553
7554 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7555 PyObject *resultobj = 0;
7556 wxRect *arg1 = (wxRect *) 0 ;
7557 wxRect *arg2 = 0 ;
7558 wxRect result;
7559 void *argp1 = 0 ;
7560 int res1 = 0 ;
7561 wxRect temp2 ;
7562 PyObject * obj0 = 0 ;
7563 PyObject * obj1 = 0 ;
7564 char * kwnames[] = {
7565 (char *) "self",(char *) "rect", NULL
7566 };
7567
7568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7570 if (!SWIG_IsOK(res1)) {
7571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7572 }
7573 arg1 = reinterpret_cast< wxRect * >(argp1);
7574 {
7575 arg2 = &temp2;
7576 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7577 }
7578 {
7579 result = (arg1)->Union((wxRect const &)*arg2);
7580 if (PyErr_Occurred()) SWIG_fail;
7581 }
7582 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7583 return resultobj;
7584 fail:
7585 return NULL;
7586 }
7587
7588
7589 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7590 PyObject *resultobj = 0;
7591 wxRect *arg1 = (wxRect *) 0 ;
7592 wxRect *arg2 = 0 ;
7593 wxRect result;
7594 void *argp1 = 0 ;
7595 int res1 = 0 ;
7596 wxRect temp2 ;
7597 PyObject * obj0 = 0 ;
7598 PyObject * obj1 = 0 ;
7599 char * kwnames[] = {
7600 (char *) "self",(char *) "rect", NULL
7601 };
7602
7603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",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___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7607 }
7608 arg1 = reinterpret_cast< wxRect * >(argp1);
7609 {
7610 arg2 = &temp2;
7611 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7612 }
7613 {
7614 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7615 if (PyErr_Occurred()) SWIG_fail;
7616 }
7617 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7618 return resultobj;
7619 fail:
7620 return NULL;
7621 }
7622
7623
7624 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7625 PyObject *resultobj = 0;
7626 wxRect *arg1 = (wxRect *) 0 ;
7627 wxRect *arg2 = 0 ;
7628 wxRect *result = 0 ;
7629 void *argp1 = 0 ;
7630 int res1 = 0 ;
7631 wxRect temp2 ;
7632 PyObject * obj0 = 0 ;
7633 PyObject * obj1 = 0 ;
7634 char * kwnames[] = {
7635 (char *) "self",(char *) "rect", NULL
7636 };
7637
7638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7640 if (!SWIG_IsOK(res1)) {
7641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7642 }
7643 arg1 = reinterpret_cast< wxRect * >(argp1);
7644 {
7645 arg2 = &temp2;
7646 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7647 }
7648 {
7649 {
7650 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7651 result = (wxRect *) &_result_ref;
7652 }
7653 if (PyErr_Occurred()) SWIG_fail;
7654 }
7655 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7656 return resultobj;
7657 fail:
7658 return NULL;
7659 }
7660
7661
7662 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7663 PyObject *resultobj = 0;
7664 wxRect *arg1 = (wxRect *) 0 ;
7665 PyObject *arg2 = (PyObject *) 0 ;
7666 bool result;
7667 void *argp1 = 0 ;
7668 int res1 = 0 ;
7669 PyObject * obj0 = 0 ;
7670 PyObject * obj1 = 0 ;
7671 char * kwnames[] = {
7672 (char *) "self",(char *) "other", NULL
7673 };
7674
7675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) 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___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7679 }
7680 arg1 = reinterpret_cast< wxRect * >(argp1);
7681 arg2 = obj1;
7682 {
7683 result = (bool)wxRect___eq__(arg1,arg2);
7684 if (PyErr_Occurred()) SWIG_fail;
7685 }
7686 {
7687 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7688 }
7689 return resultobj;
7690 fail:
7691 return NULL;
7692 }
7693
7694
7695 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7696 PyObject *resultobj = 0;
7697 wxRect *arg1 = (wxRect *) 0 ;
7698 PyObject *arg2 = (PyObject *) 0 ;
7699 bool result;
7700 void *argp1 = 0 ;
7701 int res1 = 0 ;
7702 PyObject * obj0 = 0 ;
7703 PyObject * obj1 = 0 ;
7704 char * kwnames[] = {
7705 (char *) "self",(char *) "other", NULL
7706 };
7707
7708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7710 if (!SWIG_IsOK(res1)) {
7711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7712 }
7713 arg1 = reinterpret_cast< wxRect * >(argp1);
7714 arg2 = obj1;
7715 {
7716 result = (bool)wxRect___ne__(arg1,arg2);
7717 if (PyErr_Occurred()) SWIG_fail;
7718 }
7719 {
7720 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7721 }
7722 return resultobj;
7723 fail:
7724 return NULL;
7725 }
7726
7727
7728 SWIGINTERN PyObject *_wrap_Rect_ContainsXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7729 PyObject *resultobj = 0;
7730 wxRect *arg1 = (wxRect *) 0 ;
7731 int arg2 ;
7732 int arg3 ;
7733 bool result;
7734 void *argp1 = 0 ;
7735 int res1 = 0 ;
7736 int val2 ;
7737 int ecode2 = 0 ;
7738 int val3 ;
7739 int ecode3 = 0 ;
7740 PyObject * obj0 = 0 ;
7741 PyObject * obj1 = 0 ;
7742 PyObject * obj2 = 0 ;
7743 char * kwnames[] = {
7744 (char *) "self",(char *) "x",(char *) "y", NULL
7745 };
7746
7747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_ContainsXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7749 if (!SWIG_IsOK(res1)) {
7750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7751 }
7752 arg1 = reinterpret_cast< wxRect * >(argp1);
7753 ecode2 = SWIG_AsVal_int(obj1, &val2);
7754 if (!SWIG_IsOK(ecode2)) {
7755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_ContainsXY" "', expected argument " "2"" of type '" "int""'");
7756 }
7757 arg2 = static_cast< int >(val2);
7758 ecode3 = SWIG_AsVal_int(obj2, &val3);
7759 if (!SWIG_IsOK(ecode3)) {
7760 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_ContainsXY" "', expected argument " "3"" of type '" "int""'");
7761 }
7762 arg3 = static_cast< int >(val3);
7763 {
7764 result = (bool)((wxRect const *)arg1)->Contains(arg2,arg3);
7765 if (PyErr_Occurred()) SWIG_fail;
7766 }
7767 {
7768 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7769 }
7770 return resultobj;
7771 fail:
7772 return NULL;
7773 }
7774
7775
7776 SWIGINTERN PyObject *_wrap_Rect_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7777 PyObject *resultobj = 0;
7778 wxRect *arg1 = (wxRect *) 0 ;
7779 wxPoint *arg2 = 0 ;
7780 bool result;
7781 void *argp1 = 0 ;
7782 int res1 = 0 ;
7783 wxPoint temp2 ;
7784 PyObject * obj0 = 0 ;
7785 PyObject * obj1 = 0 ;
7786 char * kwnames[] = {
7787 (char *) "self",(char *) "pt", NULL
7788 };
7789
7790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
7791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7792 if (!SWIG_IsOK(res1)) {
7793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Contains" "', expected argument " "1"" of type '" "wxRect const *""'");
7794 }
7795 arg1 = reinterpret_cast< wxRect * >(argp1);
7796 {
7797 arg2 = &temp2;
7798 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7799 }
7800 {
7801 result = (bool)((wxRect const *)arg1)->Contains((wxPoint const &)*arg2);
7802 if (PyErr_Occurred()) SWIG_fail;
7803 }
7804 {
7805 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7806 }
7807 return resultobj;
7808 fail:
7809 return NULL;
7810 }
7811
7812
7813 SWIGINTERN PyObject *_wrap_Rect_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7814 PyObject *resultobj = 0;
7815 wxRect *arg1 = (wxRect *) 0 ;
7816 wxRect *arg2 = 0 ;
7817 bool result;
7818 void *argp1 = 0 ;
7819 int res1 = 0 ;
7820 wxRect temp2 ;
7821 PyObject * obj0 = 0 ;
7822 PyObject * obj1 = 0 ;
7823 char * kwnames[] = {
7824 (char *) "self",(char *) "rect", NULL
7825 };
7826
7827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
7828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7829 if (!SWIG_IsOK(res1)) {
7830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsRect" "', expected argument " "1"" of type '" "wxRect const *""'");
7831 }
7832 arg1 = reinterpret_cast< wxRect * >(argp1);
7833 {
7834 arg2 = &temp2;
7835 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7836 }
7837 {
7838 result = (bool)((wxRect const *)arg1)->Contains((wxRect const &)*arg2);
7839 if (PyErr_Occurred()) SWIG_fail;
7840 }
7841 {
7842 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7843 }
7844 return resultobj;
7845 fail:
7846 return NULL;
7847 }
7848
7849
7850 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7851 PyObject *resultobj = 0;
7852 wxRect *arg1 = (wxRect *) 0 ;
7853 wxRect *arg2 = 0 ;
7854 bool result;
7855 void *argp1 = 0 ;
7856 int res1 = 0 ;
7857 wxRect temp2 ;
7858 PyObject * obj0 = 0 ;
7859 PyObject * obj1 = 0 ;
7860 char * kwnames[] = {
7861 (char *) "self",(char *) "rect", NULL
7862 };
7863
7864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7866 if (!SWIG_IsOK(res1)) {
7867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7868 }
7869 arg1 = reinterpret_cast< wxRect * >(argp1);
7870 {
7871 arg2 = &temp2;
7872 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7873 }
7874 {
7875 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7876 if (PyErr_Occurred()) SWIG_fail;
7877 }
7878 {
7879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7880 }
7881 return resultobj;
7882 fail:
7883 return NULL;
7884 }
7885
7886
7887 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7888 PyObject *resultobj = 0;
7889 wxRect *arg1 = (wxRect *) 0 ;
7890 wxRect *arg2 = 0 ;
7891 int arg3 = (int) wxBOTH ;
7892 wxRect result;
7893 void *argp1 = 0 ;
7894 int res1 = 0 ;
7895 wxRect temp2 ;
7896 int val3 ;
7897 int ecode3 = 0 ;
7898 PyObject * obj0 = 0 ;
7899 PyObject * obj1 = 0 ;
7900 PyObject * obj2 = 0 ;
7901 char * kwnames[] = {
7902 (char *) "self",(char *) "r",(char *) "dir", NULL
7903 };
7904
7905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7907 if (!SWIG_IsOK(res1)) {
7908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7909 }
7910 arg1 = reinterpret_cast< wxRect * >(argp1);
7911 {
7912 arg2 = &temp2;
7913 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7914 }
7915 if (obj2) {
7916 ecode3 = SWIG_AsVal_int(obj2, &val3);
7917 if (!SWIG_IsOK(ecode3)) {
7918 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7919 }
7920 arg3 = static_cast< int >(val3);
7921 }
7922 {
7923 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7924 if (PyErr_Occurred()) SWIG_fail;
7925 }
7926 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7927 return resultobj;
7928 fail:
7929 return NULL;
7930 }
7931
7932
7933 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7934 PyObject *resultobj = 0;
7935 wxRect *arg1 = (wxRect *) 0 ;
7936 int arg2 ;
7937 void *argp1 = 0 ;
7938 int res1 = 0 ;
7939 int val2 ;
7940 int ecode2 = 0 ;
7941 PyObject *swig_obj[2] ;
7942
7943 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7945 if (!SWIG_IsOK(res1)) {
7946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7947 }
7948 arg1 = reinterpret_cast< wxRect * >(argp1);
7949 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7950 if (!SWIG_IsOK(ecode2)) {
7951 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7952 }
7953 arg2 = static_cast< int >(val2);
7954 if (arg1) (arg1)->x = arg2;
7955
7956 resultobj = SWIG_Py_Void();
7957 return resultobj;
7958 fail:
7959 return NULL;
7960 }
7961
7962
7963 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7964 PyObject *resultobj = 0;
7965 wxRect *arg1 = (wxRect *) 0 ;
7966 int result;
7967 void *argp1 = 0 ;
7968 int res1 = 0 ;
7969 PyObject *swig_obj[1] ;
7970
7971 if (!args) SWIG_fail;
7972 swig_obj[0] = args;
7973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7974 if (!SWIG_IsOK(res1)) {
7975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7976 }
7977 arg1 = reinterpret_cast< wxRect * >(argp1);
7978 result = (int) ((arg1)->x);
7979 resultobj = SWIG_From_int(static_cast< int >(result));
7980 return resultobj;
7981 fail:
7982 return NULL;
7983 }
7984
7985
7986 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7987 PyObject *resultobj = 0;
7988 wxRect *arg1 = (wxRect *) 0 ;
7989 int arg2 ;
7990 void *argp1 = 0 ;
7991 int res1 = 0 ;
7992 int val2 ;
7993 int ecode2 = 0 ;
7994 PyObject *swig_obj[2] ;
7995
7996 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7998 if (!SWIG_IsOK(res1)) {
7999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
8000 }
8001 arg1 = reinterpret_cast< wxRect * >(argp1);
8002 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8003 if (!SWIG_IsOK(ecode2)) {
8004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
8005 }
8006 arg2 = static_cast< int >(val2);
8007 if (arg1) (arg1)->y = arg2;
8008
8009 resultobj = SWIG_Py_Void();
8010 return resultobj;
8011 fail:
8012 return NULL;
8013 }
8014
8015
8016 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8017 PyObject *resultobj = 0;
8018 wxRect *arg1 = (wxRect *) 0 ;
8019 int result;
8020 void *argp1 = 0 ;
8021 int res1 = 0 ;
8022 PyObject *swig_obj[1] ;
8023
8024 if (!args) SWIG_fail;
8025 swig_obj[0] = args;
8026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8027 if (!SWIG_IsOK(res1)) {
8028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
8029 }
8030 arg1 = reinterpret_cast< wxRect * >(argp1);
8031 result = (int) ((arg1)->y);
8032 resultobj = SWIG_From_int(static_cast< int >(result));
8033 return resultobj;
8034 fail:
8035 return NULL;
8036 }
8037
8038
8039 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8040 PyObject *resultobj = 0;
8041 wxRect *arg1 = (wxRect *) 0 ;
8042 int arg2 ;
8043 void *argp1 = 0 ;
8044 int res1 = 0 ;
8045 int val2 ;
8046 int ecode2 = 0 ;
8047 PyObject *swig_obj[2] ;
8048
8049 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
8050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8051 if (!SWIG_IsOK(res1)) {
8052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
8053 }
8054 arg1 = reinterpret_cast< wxRect * >(argp1);
8055 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8056 if (!SWIG_IsOK(ecode2)) {
8057 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
8058 }
8059 arg2 = static_cast< int >(val2);
8060 if (arg1) (arg1)->width = arg2;
8061
8062 resultobj = SWIG_Py_Void();
8063 return resultobj;
8064 fail:
8065 return NULL;
8066 }
8067
8068
8069 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8070 PyObject *resultobj = 0;
8071 wxRect *arg1 = (wxRect *) 0 ;
8072 int result;
8073 void *argp1 = 0 ;
8074 int res1 = 0 ;
8075 PyObject *swig_obj[1] ;
8076
8077 if (!args) SWIG_fail;
8078 swig_obj[0] = args;
8079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8080 if (!SWIG_IsOK(res1)) {
8081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
8082 }
8083 arg1 = reinterpret_cast< wxRect * >(argp1);
8084 result = (int) ((arg1)->width);
8085 resultobj = SWIG_From_int(static_cast< int >(result));
8086 return resultobj;
8087 fail:
8088 return NULL;
8089 }
8090
8091
8092 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8093 PyObject *resultobj = 0;
8094 wxRect *arg1 = (wxRect *) 0 ;
8095 int arg2 ;
8096 void *argp1 = 0 ;
8097 int res1 = 0 ;
8098 int val2 ;
8099 int ecode2 = 0 ;
8100 PyObject *swig_obj[2] ;
8101
8102 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
8103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8104 if (!SWIG_IsOK(res1)) {
8105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
8106 }
8107 arg1 = reinterpret_cast< wxRect * >(argp1);
8108 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8109 if (!SWIG_IsOK(ecode2)) {
8110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
8111 }
8112 arg2 = static_cast< int >(val2);
8113 if (arg1) (arg1)->height = arg2;
8114
8115 resultobj = SWIG_Py_Void();
8116 return resultobj;
8117 fail:
8118 return NULL;
8119 }
8120
8121
8122 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8123 PyObject *resultobj = 0;
8124 wxRect *arg1 = (wxRect *) 0 ;
8125 int result;
8126 void *argp1 = 0 ;
8127 int res1 = 0 ;
8128 PyObject *swig_obj[1] ;
8129
8130 if (!args) SWIG_fail;
8131 swig_obj[0] = args;
8132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8133 if (!SWIG_IsOK(res1)) {
8134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
8135 }
8136 arg1 = reinterpret_cast< wxRect * >(argp1);
8137 result = (int) ((arg1)->height);
8138 resultobj = SWIG_From_int(static_cast< int >(result));
8139 return resultobj;
8140 fail:
8141 return NULL;
8142 }
8143
8144
8145 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8146 PyObject *resultobj = 0;
8147 wxRect *arg1 = (wxRect *) 0 ;
8148 int arg2 = (int) 0 ;
8149 int arg3 = (int) 0 ;
8150 int arg4 = (int) 0 ;
8151 int arg5 = (int) 0 ;
8152 void *argp1 = 0 ;
8153 int res1 = 0 ;
8154 int val2 ;
8155 int ecode2 = 0 ;
8156 int val3 ;
8157 int ecode3 = 0 ;
8158 int val4 ;
8159 int ecode4 = 0 ;
8160 int val5 ;
8161 int ecode5 = 0 ;
8162 PyObject * obj0 = 0 ;
8163 PyObject * obj1 = 0 ;
8164 PyObject * obj2 = 0 ;
8165 PyObject * obj3 = 0 ;
8166 PyObject * obj4 = 0 ;
8167 char * kwnames[] = {
8168 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
8169 };
8170
8171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8173 if (!SWIG_IsOK(res1)) {
8174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
8175 }
8176 arg1 = reinterpret_cast< wxRect * >(argp1);
8177 if (obj1) {
8178 ecode2 = SWIG_AsVal_int(obj1, &val2);
8179 if (!SWIG_IsOK(ecode2)) {
8180 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
8181 }
8182 arg2 = static_cast< int >(val2);
8183 }
8184 if (obj2) {
8185 ecode3 = SWIG_AsVal_int(obj2, &val3);
8186 if (!SWIG_IsOK(ecode3)) {
8187 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
8188 }
8189 arg3 = static_cast< int >(val3);
8190 }
8191 if (obj3) {
8192 ecode4 = SWIG_AsVal_int(obj3, &val4);
8193 if (!SWIG_IsOK(ecode4)) {
8194 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
8195 }
8196 arg4 = static_cast< int >(val4);
8197 }
8198 if (obj4) {
8199 ecode5 = SWIG_AsVal_int(obj4, &val5);
8200 if (!SWIG_IsOK(ecode5)) {
8201 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
8202 }
8203 arg5 = static_cast< int >(val5);
8204 }
8205 {
8206 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
8207 if (PyErr_Occurred()) SWIG_fail;
8208 }
8209 resultobj = SWIG_Py_Void();
8210 return resultobj;
8211 fail:
8212 return NULL;
8213 }
8214
8215
8216 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8217 PyObject *resultobj = 0;
8218 wxRect *arg1 = (wxRect *) 0 ;
8219 PyObject *result = 0 ;
8220 void *argp1 = 0 ;
8221 int res1 = 0 ;
8222 PyObject *swig_obj[1] ;
8223
8224 if (!args) SWIG_fail;
8225 swig_obj[0] = args;
8226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8227 if (!SWIG_IsOK(res1)) {
8228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
8229 }
8230 arg1 = reinterpret_cast< wxRect * >(argp1);
8231 {
8232 result = (PyObject *)wxRect_Get(arg1);
8233 if (PyErr_Occurred()) SWIG_fail;
8234 }
8235 resultobj = result;
8236 return resultobj;
8237 fail:
8238 return NULL;
8239 }
8240
8241
8242 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8243 PyObject *obj;
8244 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8245 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
8246 return SWIG_Py_Void();
8247 }
8248
8249 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8250 return SWIG_Python_InitShadowInstance(args);
8251 }
8252
8253 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8254 PyObject *resultobj = 0;
8255 wxRect *arg1 = (wxRect *) 0 ;
8256 wxRect *arg2 = (wxRect *) 0 ;
8257 PyObject *result = 0 ;
8258 void *argp1 = 0 ;
8259 int res1 = 0 ;
8260 void *argp2 = 0 ;
8261 int res2 = 0 ;
8262 PyObject * obj0 = 0 ;
8263 PyObject * obj1 = 0 ;
8264 char * kwnames[] = {
8265 (char *) "r1",(char *) "r2", NULL
8266 };
8267
8268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
8269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8270 if (!SWIG_IsOK(res1)) {
8271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
8272 }
8273 arg1 = reinterpret_cast< wxRect * >(argp1);
8274 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
8275 if (!SWIG_IsOK(res2)) {
8276 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
8277 }
8278 arg2 = reinterpret_cast< wxRect * >(argp2);
8279 {
8280 if (!wxPyCheckForApp()) SWIG_fail;
8281 PyThreadState* __tstate = wxPyBeginAllowThreads();
8282 result = (PyObject *)wxIntersectRect(arg1,arg2);
8283 wxPyEndAllowThreads(__tstate);
8284 if (PyErr_Occurred()) SWIG_fail;
8285 }
8286 resultobj = result;
8287 return resultobj;
8288 fail:
8289 return NULL;
8290 }
8291
8292
8293 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8294 PyObject *resultobj = 0;
8295 double arg1 = (double) 0.0 ;
8296 double arg2 = (double) 0.0 ;
8297 wxPoint2D *result = 0 ;
8298 double val1 ;
8299 int ecode1 = 0 ;
8300 double val2 ;
8301 int ecode2 = 0 ;
8302 PyObject * obj0 = 0 ;
8303 PyObject * obj1 = 0 ;
8304 char * kwnames[] = {
8305 (char *) "x",(char *) "y", NULL
8306 };
8307
8308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8309 if (obj0) {
8310 ecode1 = SWIG_AsVal_double(obj0, &val1);
8311 if (!SWIG_IsOK(ecode1)) {
8312 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8313 }
8314 arg1 = static_cast< double >(val1);
8315 }
8316 if (obj1) {
8317 ecode2 = SWIG_AsVal_double(obj1, &val2);
8318 if (!SWIG_IsOK(ecode2)) {
8319 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8320 }
8321 arg2 = static_cast< double >(val2);
8322 }
8323 {
8324 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8325 if (PyErr_Occurred()) SWIG_fail;
8326 }
8327 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8328 return resultobj;
8329 fail:
8330 return NULL;
8331 }
8332
8333
8334 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8335 PyObject *resultobj = 0;
8336 wxPoint2D *arg1 = 0 ;
8337 wxPoint2D *result = 0 ;
8338 wxPoint2D temp1 ;
8339 PyObject * obj0 = 0 ;
8340 char * kwnames[] = {
8341 (char *) "pt", NULL
8342 };
8343
8344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8345 {
8346 arg1 = &temp1;
8347 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8348 }
8349 {
8350 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8351 if (PyErr_Occurred()) SWIG_fail;
8352 }
8353 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8354 return resultobj;
8355 fail:
8356 return NULL;
8357 }
8358
8359
8360 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8361 PyObject *resultobj = 0;
8362 wxPoint *arg1 = 0 ;
8363 wxPoint2D *result = 0 ;
8364 wxPoint temp1 ;
8365 PyObject * obj0 = 0 ;
8366 char * kwnames[] = {
8367 (char *) "pt", NULL
8368 };
8369
8370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8371 {
8372 arg1 = &temp1;
8373 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8374 }
8375 {
8376 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8377 if (PyErr_Occurred()) SWIG_fail;
8378 }
8379 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8380 return resultobj;
8381 fail:
8382 return NULL;
8383 }
8384
8385
8386 SWIGINTERN PyObject *_wrap_delete_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8387 PyObject *resultobj = 0;
8388 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8389 void *argp1 = 0 ;
8390 int res1 = 0 ;
8391 PyObject *swig_obj[1] ;
8392
8393 if (!args) SWIG_fail;
8394 swig_obj[0] = args;
8395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8396 if (!SWIG_IsOK(res1)) {
8397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point2D" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8398 }
8399 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8400 {
8401 delete arg1;
8402
8403 if (PyErr_Occurred()) SWIG_fail;
8404 }
8405 resultobj = SWIG_Py_Void();
8406 return resultobj;
8407 fail:
8408 return NULL;
8409 }
8410
8411
8412 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8413 PyObject *resultobj = 0;
8414 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8415 int *arg2 = (int *) 0 ;
8416 int *arg3 = (int *) 0 ;
8417 void *argp1 = 0 ;
8418 int res1 = 0 ;
8419 int temp2 ;
8420 int res2 = SWIG_TMPOBJ ;
8421 int temp3 ;
8422 int res3 = SWIG_TMPOBJ ;
8423 PyObject *swig_obj[1] ;
8424
8425 arg2 = &temp2;
8426 arg3 = &temp3;
8427 if (!args) SWIG_fail;
8428 swig_obj[0] = args;
8429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8430 if (!SWIG_IsOK(res1)) {
8431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8432 }
8433 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8434 {
8435 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8436 if (PyErr_Occurred()) SWIG_fail;
8437 }
8438 resultobj = SWIG_Py_Void();
8439 if (SWIG_IsTmpObj(res2)) {
8440 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8441 } else {
8442 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8443 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8444 }
8445 if (SWIG_IsTmpObj(res3)) {
8446 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8447 } else {
8448 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8449 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8450 }
8451 return resultobj;
8452 fail:
8453 return NULL;
8454 }
8455
8456
8457 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8458 PyObject *resultobj = 0;
8459 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8460 int *arg2 = (int *) 0 ;
8461 int *arg3 = (int *) 0 ;
8462 void *argp1 = 0 ;
8463 int res1 = 0 ;
8464 int temp2 ;
8465 int res2 = SWIG_TMPOBJ ;
8466 int temp3 ;
8467 int res3 = SWIG_TMPOBJ ;
8468 PyObject *swig_obj[1] ;
8469
8470 arg2 = &temp2;
8471 arg3 = &temp3;
8472 if (!args) SWIG_fail;
8473 swig_obj[0] = args;
8474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8475 if (!SWIG_IsOK(res1)) {
8476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8477 }
8478 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8479 {
8480 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8481 if (PyErr_Occurred()) SWIG_fail;
8482 }
8483 resultobj = SWIG_Py_Void();
8484 if (SWIG_IsTmpObj(res2)) {
8485 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8486 } else {
8487 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8488 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8489 }
8490 if (SWIG_IsTmpObj(res3)) {
8491 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8492 } else {
8493 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8494 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8495 }
8496 return resultobj;
8497 fail:
8498 return NULL;
8499 }
8500
8501
8502 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8503 PyObject *resultobj = 0;
8504 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8505 double result;
8506 void *argp1 = 0 ;
8507 int res1 = 0 ;
8508 PyObject *swig_obj[1] ;
8509
8510 if (!args) SWIG_fail;
8511 swig_obj[0] = args;
8512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8513 if (!SWIG_IsOK(res1)) {
8514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8515 }
8516 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8517 {
8518 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8519 if (PyErr_Occurred()) SWIG_fail;
8520 }
8521 resultobj = SWIG_From_double(static_cast< double >(result));
8522 return resultobj;
8523 fail:
8524 return NULL;
8525 }
8526
8527
8528 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8529 PyObject *resultobj = 0;
8530 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8531 double result;
8532 void *argp1 = 0 ;
8533 int res1 = 0 ;
8534 PyObject *swig_obj[1] ;
8535
8536 if (!args) SWIG_fail;
8537 swig_obj[0] = args;
8538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8539 if (!SWIG_IsOK(res1)) {
8540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8541 }
8542 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8543 {
8544 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8545 if (PyErr_Occurred()) SWIG_fail;
8546 }
8547 resultobj = SWIG_From_double(static_cast< double >(result));
8548 return resultobj;
8549 fail:
8550 return NULL;
8551 }
8552
8553
8554 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8555 PyObject *resultobj = 0;
8556 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8557 double arg2 ;
8558 void *argp1 = 0 ;
8559 int res1 = 0 ;
8560 double val2 ;
8561 int ecode2 = 0 ;
8562 PyObject * obj0 = 0 ;
8563 PyObject * obj1 = 0 ;
8564 char * kwnames[] = {
8565 (char *) "self",(char *) "length", NULL
8566 };
8567
8568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",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_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8572 }
8573 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8574 ecode2 = SWIG_AsVal_double(obj1, &val2);
8575 if (!SWIG_IsOK(ecode2)) {
8576 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8577 }
8578 arg2 = static_cast< double >(val2);
8579 {
8580 (arg1)->SetVectorLength(arg2);
8581 if (PyErr_Occurred()) SWIG_fail;
8582 }
8583 resultobj = SWIG_Py_Void();
8584 return resultobj;
8585 fail:
8586 return NULL;
8587 }
8588
8589
8590 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8591 PyObject *resultobj = 0;
8592 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8593 double arg2 ;
8594 void *argp1 = 0 ;
8595 int res1 = 0 ;
8596 double val2 ;
8597 int ecode2 = 0 ;
8598 PyObject * obj0 = 0 ;
8599 PyObject * obj1 = 0 ;
8600 char * kwnames[] = {
8601 (char *) "self",(char *) "degrees", NULL
8602 };
8603
8604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8606 if (!SWIG_IsOK(res1)) {
8607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8608 }
8609 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8610 ecode2 = SWIG_AsVal_double(obj1, &val2);
8611 if (!SWIG_IsOK(ecode2)) {
8612 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8613 }
8614 arg2 = static_cast< double >(val2);
8615 {
8616 (arg1)->SetVectorAngle(arg2);
8617 if (PyErr_Occurred()) SWIG_fail;
8618 }
8619 resultobj = SWIG_Py_Void();
8620 return resultobj;
8621 fail:
8622 return NULL;
8623 }
8624
8625
8626 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8627 PyObject *resultobj = 0;
8628 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8629 wxPoint2D *arg2 = 0 ;
8630 double result;
8631 void *argp1 = 0 ;
8632 int res1 = 0 ;
8633 wxPoint2D temp2 ;
8634 PyObject * obj0 = 0 ;
8635 PyObject * obj1 = 0 ;
8636 char * kwnames[] = {
8637 (char *) "self",(char *) "pt", NULL
8638 };
8639
8640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8642 if (!SWIG_IsOK(res1)) {
8643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8644 }
8645 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8646 {
8647 arg2 = &temp2;
8648 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8649 }
8650 {
8651 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8652 if (PyErr_Occurred()) SWIG_fail;
8653 }
8654 resultobj = SWIG_From_double(static_cast< double >(result));
8655 return resultobj;
8656 fail:
8657 return NULL;
8658 }
8659
8660
8661 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8662 PyObject *resultobj = 0;
8663 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8664 wxPoint2D *arg2 = 0 ;
8665 double result;
8666 void *argp1 = 0 ;
8667 int res1 = 0 ;
8668 wxPoint2D temp2 ;
8669 PyObject * obj0 = 0 ;
8670 PyObject * obj1 = 0 ;
8671 char * kwnames[] = {
8672 (char *) "self",(char *) "pt", NULL
8673 };
8674
8675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8677 if (!SWIG_IsOK(res1)) {
8678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8679 }
8680 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8681 {
8682 arg2 = &temp2;
8683 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8684 }
8685 {
8686 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8687 if (PyErr_Occurred()) SWIG_fail;
8688 }
8689 resultobj = SWIG_From_double(static_cast< double >(result));
8690 return resultobj;
8691 fail:
8692 return NULL;
8693 }
8694
8695
8696 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8697 PyObject *resultobj = 0;
8698 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8699 wxPoint2D *arg2 = 0 ;
8700 double result;
8701 void *argp1 = 0 ;
8702 int res1 = 0 ;
8703 wxPoint2D temp2 ;
8704 PyObject * obj0 = 0 ;
8705 PyObject * obj1 = 0 ;
8706 char * kwnames[] = {
8707 (char *) "self",(char *) "vec", NULL
8708 };
8709
8710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8711 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8712 if (!SWIG_IsOK(res1)) {
8713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8714 }
8715 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8716 {
8717 arg2 = &temp2;
8718 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8719 }
8720 {
8721 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8722 if (PyErr_Occurred()) SWIG_fail;
8723 }
8724 resultobj = SWIG_From_double(static_cast< double >(result));
8725 return resultobj;
8726 fail:
8727 return NULL;
8728 }
8729
8730
8731 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8732 PyObject *resultobj = 0;
8733 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8734 wxPoint2D *arg2 = 0 ;
8735 double result;
8736 void *argp1 = 0 ;
8737 int res1 = 0 ;
8738 wxPoint2D temp2 ;
8739 PyObject * obj0 = 0 ;
8740 PyObject * obj1 = 0 ;
8741 char * kwnames[] = {
8742 (char *) "self",(char *) "vec", NULL
8743 };
8744
8745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8747 if (!SWIG_IsOK(res1)) {
8748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8749 }
8750 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8751 {
8752 arg2 = &temp2;
8753 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8754 }
8755 {
8756 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8757 if (PyErr_Occurred()) SWIG_fail;
8758 }
8759 resultobj = SWIG_From_double(static_cast< double >(result));
8760 return resultobj;
8761 fail:
8762 return NULL;
8763 }
8764
8765
8766 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8767 PyObject *resultobj = 0;
8768 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8769 wxPoint2D result;
8770 void *argp1 = 0 ;
8771 int res1 = 0 ;
8772 PyObject *swig_obj[1] ;
8773
8774 if (!args) SWIG_fail;
8775 swig_obj[0] = args;
8776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8777 if (!SWIG_IsOK(res1)) {
8778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8779 }
8780 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8781 {
8782 result = (arg1)->operator -();
8783 if (PyErr_Occurred()) SWIG_fail;
8784 }
8785 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8786 return resultobj;
8787 fail:
8788 return NULL;
8789 }
8790
8791
8792 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8793 PyObject *resultobj = 0;
8794 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8795 wxPoint2D *arg2 = 0 ;
8796 wxPoint2D *result = 0 ;
8797 void *argp1 = 0 ;
8798 int res1 = 0 ;
8799 wxPoint2D temp2 ;
8800 PyObject * obj0 = 0 ;
8801 PyObject * obj1 = 0 ;
8802 char * kwnames[] = {
8803 (char *) "self",(char *) "pt", NULL
8804 };
8805
8806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8808 if (!SWIG_IsOK(res1)) {
8809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8810 }
8811 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8812 {
8813 arg2 = &temp2;
8814 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8815 }
8816 {
8817 {
8818 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8819 result = (wxPoint2D *) &_result_ref;
8820 }
8821 if (PyErr_Occurred()) SWIG_fail;
8822 }
8823 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8824 return resultobj;
8825 fail:
8826 return NULL;
8827 }
8828
8829
8830 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8831 PyObject *resultobj = 0;
8832 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8833 wxPoint2D *arg2 = 0 ;
8834 wxPoint2D *result = 0 ;
8835 void *argp1 = 0 ;
8836 int res1 = 0 ;
8837 wxPoint2D temp2 ;
8838 PyObject * obj0 = 0 ;
8839 PyObject * obj1 = 0 ;
8840 char * kwnames[] = {
8841 (char *) "self",(char *) "pt", NULL
8842 };
8843
8844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8846 if (!SWIG_IsOK(res1)) {
8847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8848 }
8849 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8850 {
8851 arg2 = &temp2;
8852 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8853 }
8854 {
8855 {
8856 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8857 result = (wxPoint2D *) &_result_ref;
8858 }
8859 if (PyErr_Occurred()) SWIG_fail;
8860 }
8861 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8862 return resultobj;
8863 fail:
8864 return NULL;
8865 }
8866
8867
8868 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8869 PyObject *resultobj = 0;
8870 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8871 wxPoint2D *arg2 = 0 ;
8872 wxPoint2D *result = 0 ;
8873 void *argp1 = 0 ;
8874 int res1 = 0 ;
8875 wxPoint2D temp2 ;
8876 PyObject * obj0 = 0 ;
8877 PyObject * obj1 = 0 ;
8878 char * kwnames[] = {
8879 (char *) "self",(char *) "pt", NULL
8880 };
8881
8882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8884 if (!SWIG_IsOK(res1)) {
8885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8886 }
8887 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8888 {
8889 arg2 = &temp2;
8890 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8891 }
8892 {
8893 {
8894 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8895 result = (wxPoint2D *) &_result_ref;
8896 }
8897 if (PyErr_Occurred()) SWIG_fail;
8898 }
8899 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8900 return resultobj;
8901 fail:
8902 return NULL;
8903 }
8904
8905
8906 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8907 PyObject *resultobj = 0;
8908 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8909 wxPoint2D *arg2 = 0 ;
8910 wxPoint2D *result = 0 ;
8911 void *argp1 = 0 ;
8912 int res1 = 0 ;
8913 wxPoint2D temp2 ;
8914 PyObject * obj0 = 0 ;
8915 PyObject * obj1 = 0 ;
8916 char * kwnames[] = {
8917 (char *) "self",(char *) "pt", NULL
8918 };
8919
8920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8922 if (!SWIG_IsOK(res1)) {
8923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8924 }
8925 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8926 {
8927 arg2 = &temp2;
8928 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8929 }
8930 {
8931 {
8932 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8933 result = (wxPoint2D *) &_result_ref;
8934 }
8935 if (PyErr_Occurred()) SWIG_fail;
8936 }
8937 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8938 return resultobj;
8939 fail:
8940 return NULL;
8941 }
8942
8943
8944 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8945 PyObject *resultobj = 0;
8946 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8947 PyObject *arg2 = (PyObject *) 0 ;
8948 bool result;
8949 void *argp1 = 0 ;
8950 int res1 = 0 ;
8951 PyObject * obj0 = 0 ;
8952 PyObject * obj1 = 0 ;
8953 char * kwnames[] = {
8954 (char *) "self",(char *) "other", NULL
8955 };
8956
8957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8959 if (!SWIG_IsOK(res1)) {
8960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8961 }
8962 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8963 arg2 = obj1;
8964 {
8965 result = (bool)wxPoint2D___eq__(arg1,arg2);
8966 if (PyErr_Occurred()) SWIG_fail;
8967 }
8968 {
8969 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8970 }
8971 return resultobj;
8972 fail:
8973 return NULL;
8974 }
8975
8976
8977 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8978 PyObject *resultobj = 0;
8979 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8980 PyObject *arg2 = (PyObject *) 0 ;
8981 bool result;
8982 void *argp1 = 0 ;
8983 int res1 = 0 ;
8984 PyObject * obj0 = 0 ;
8985 PyObject * obj1 = 0 ;
8986 char * kwnames[] = {
8987 (char *) "self",(char *) "other", NULL
8988 };
8989
8990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8992 if (!SWIG_IsOK(res1)) {
8993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8994 }
8995 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8996 arg2 = obj1;
8997 {
8998 result = (bool)wxPoint2D___ne__(arg1,arg2);
8999 if (PyErr_Occurred()) SWIG_fail;
9000 }
9001 {
9002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9003 }
9004 return resultobj;
9005 fail:
9006 return NULL;
9007 }
9008
9009
9010 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9011 PyObject *resultobj = 0;
9012 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9013 double arg2 ;
9014 void *argp1 = 0 ;
9015 int res1 = 0 ;
9016 double val2 ;
9017 int ecode2 = 0 ;
9018 PyObject *swig_obj[2] ;
9019
9020 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
9021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9022 if (!SWIG_IsOK(res1)) {
9023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9024 }
9025 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9026 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9027 if (!SWIG_IsOK(ecode2)) {
9028 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
9029 }
9030 arg2 = static_cast< double >(val2);
9031 if (arg1) (arg1)->m_x = arg2;
9032
9033 resultobj = SWIG_Py_Void();
9034 return resultobj;
9035 fail:
9036 return NULL;
9037 }
9038
9039
9040 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9041 PyObject *resultobj = 0;
9042 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9043 double result;
9044 void *argp1 = 0 ;
9045 int res1 = 0 ;
9046 PyObject *swig_obj[1] ;
9047
9048 if (!args) SWIG_fail;
9049 swig_obj[0] = args;
9050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9051 if (!SWIG_IsOK(res1)) {
9052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9053 }
9054 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9055 result = (double) ((arg1)->m_x);
9056 resultobj = SWIG_From_double(static_cast< double >(result));
9057 return resultobj;
9058 fail:
9059 return NULL;
9060 }
9061
9062
9063 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9064 PyObject *resultobj = 0;
9065 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9066 double arg2 ;
9067 void *argp1 = 0 ;
9068 int res1 = 0 ;
9069 double val2 ;
9070 int ecode2 = 0 ;
9071 PyObject *swig_obj[2] ;
9072
9073 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
9074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9075 if (!SWIG_IsOK(res1)) {
9076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9077 }
9078 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9079 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9080 if (!SWIG_IsOK(ecode2)) {
9081 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
9082 }
9083 arg2 = static_cast< double >(val2);
9084 if (arg1) (arg1)->m_y = arg2;
9085
9086 resultobj = SWIG_Py_Void();
9087 return resultobj;
9088 fail:
9089 return NULL;
9090 }
9091
9092
9093 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9094 PyObject *resultobj = 0;
9095 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9096 double result;
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_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9106 }
9107 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9108 result = (double) ((arg1)->m_y);
9109 resultobj = SWIG_From_double(static_cast< double >(result));
9110 return resultobj;
9111 fail:
9112 return NULL;
9113 }
9114
9115
9116 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9117 PyObject *resultobj = 0;
9118 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9119 double arg2 = (double) 0 ;
9120 double arg3 = (double) 0 ;
9121 void *argp1 = 0 ;
9122 int res1 = 0 ;
9123 double val2 ;
9124 int ecode2 = 0 ;
9125 double val3 ;
9126 int ecode3 = 0 ;
9127 PyObject * obj0 = 0 ;
9128 PyObject * obj1 = 0 ;
9129 PyObject * obj2 = 0 ;
9130 char * kwnames[] = {
9131 (char *) "self",(char *) "x",(char *) "y", NULL
9132 };
9133
9134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9136 if (!SWIG_IsOK(res1)) {
9137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9138 }
9139 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9140 if (obj1) {
9141 ecode2 = SWIG_AsVal_double(obj1, &val2);
9142 if (!SWIG_IsOK(ecode2)) {
9143 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
9144 }
9145 arg2 = static_cast< double >(val2);
9146 }
9147 if (obj2) {
9148 ecode3 = SWIG_AsVal_double(obj2, &val3);
9149 if (!SWIG_IsOK(ecode3)) {
9150 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
9151 }
9152 arg3 = static_cast< double >(val3);
9153 }
9154 {
9155 wxPoint2D_Set(arg1,arg2,arg3);
9156 if (PyErr_Occurred()) SWIG_fail;
9157 }
9158 resultobj = SWIG_Py_Void();
9159 return resultobj;
9160 fail:
9161 return NULL;
9162 }
9163
9164
9165 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9166 PyObject *resultobj = 0;
9167 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9168 PyObject *result = 0 ;
9169 void *argp1 = 0 ;
9170 int res1 = 0 ;
9171 PyObject *swig_obj[1] ;
9172
9173 if (!args) SWIG_fail;
9174 swig_obj[0] = args;
9175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9176 if (!SWIG_IsOK(res1)) {
9177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9178 }
9179 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9180 {
9181 result = (PyObject *)wxPoint2D_Get(arg1);
9182 if (PyErr_Occurred()) SWIG_fail;
9183 }
9184 resultobj = result;
9185 return resultobj;
9186 fail:
9187 return NULL;
9188 }
9189
9190
9191 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9192 PyObject *obj;
9193 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9194 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
9195 return SWIG_Py_Void();
9196 }
9197
9198 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9199 return SWIG_Python_InitShadowInstance(args);
9200 }
9201
9202 SWIGINTERN PyObject *_wrap_new_Rect2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9203 PyObject *resultobj = 0;
9204 wxDouble arg1 = (wxDouble) 0.0 ;
9205 wxDouble arg2 = (wxDouble) 0.0 ;
9206 wxDouble arg3 = (wxDouble) 0.0 ;
9207 wxDouble arg4 = (wxDouble) 0.0 ;
9208 wxRect2D *result = 0 ;
9209 void *argp1 ;
9210 int res1 = 0 ;
9211 void *argp2 ;
9212 int res2 = 0 ;
9213 void *argp3 ;
9214 int res3 = 0 ;
9215 void *argp4 ;
9216 int res4 = 0 ;
9217 PyObject * obj0 = 0 ;
9218 PyObject * obj1 = 0 ;
9219 PyObject * obj2 = 0 ;
9220 PyObject * obj3 = 0 ;
9221 char * kwnames[] = {
9222 (char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
9223 };
9224
9225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect2D",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9226 if (obj0) {
9227 {
9228 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDouble, 0 | 0);
9229 if (!SWIG_IsOK(res1)) {
9230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Rect2D" "', expected argument " "1"" of type '" "wxDouble""'");
9231 }
9232 if (!argp1) {
9233 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "1"" of type '" "wxDouble""'");
9234 } else {
9235 wxDouble * temp = reinterpret_cast< wxDouble * >(argp1);
9236 arg1 = *temp;
9237 if (SWIG_IsNewObj(res1)) delete temp;
9238 }
9239 }
9240 }
9241 if (obj1) {
9242 {
9243 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9244 if (!SWIG_IsOK(res2)) {
9245 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Rect2D" "', expected argument " "2"" of type '" "wxDouble""'");
9246 }
9247 if (!argp2) {
9248 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "2"" of type '" "wxDouble""'");
9249 } else {
9250 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9251 arg2 = *temp;
9252 if (SWIG_IsNewObj(res2)) delete temp;
9253 }
9254 }
9255 }
9256 if (obj2) {
9257 {
9258 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
9259 if (!SWIG_IsOK(res3)) {
9260 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Rect2D" "', expected argument " "3"" of type '" "wxDouble""'");
9261 }
9262 if (!argp3) {
9263 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "3"" of type '" "wxDouble""'");
9264 } else {
9265 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
9266 arg3 = *temp;
9267 if (SWIG_IsNewObj(res3)) delete temp;
9268 }
9269 }
9270 }
9271 if (obj3) {
9272 {
9273 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
9274 if (!SWIG_IsOK(res4)) {
9275 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Rect2D" "', expected argument " "4"" of type '" "wxDouble""'");
9276 }
9277 if (!argp4) {
9278 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "4"" of type '" "wxDouble""'");
9279 } else {
9280 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
9281 arg4 = *temp;
9282 if (SWIG_IsNewObj(res4)) delete temp;
9283 }
9284 }
9285 }
9286 {
9287 result = (wxRect2D *)new wxRect2D(arg1,arg2,arg3,arg4);
9288 if (PyErr_Occurred()) SWIG_fail;
9289 }
9290 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect2D, SWIG_POINTER_NEW | 0 );
9291 return resultobj;
9292 fail:
9293 return NULL;
9294 }
9295
9296
9297 SWIGINTERN PyObject *_wrap_delete_Rect2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9298 PyObject *resultobj = 0;
9299 wxRect2D *arg1 = (wxRect2D *) 0 ;
9300 void *argp1 = 0 ;
9301 int res1 = 0 ;
9302 PyObject *swig_obj[1] ;
9303
9304 if (!args) SWIG_fail;
9305 swig_obj[0] = args;
9306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, SWIG_POINTER_DISOWN | 0 );
9307 if (!SWIG_IsOK(res1)) {
9308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect2D" "', expected argument " "1"" of type '" "wxRect2D *""'");
9309 }
9310 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9311 {
9312 delete arg1;
9313
9314 if (PyErr_Occurred()) SWIG_fail;
9315 }
9316 resultobj = SWIG_Py_Void();
9317 return resultobj;
9318 fail:
9319 return NULL;
9320 }
9321
9322
9323 SWIGINTERN PyObject *_wrap_Rect2D_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9324 PyObject *resultobj = 0;
9325 wxRect2D *arg1 = (wxRect2D *) 0 ;
9326 wxPoint2D result;
9327 void *argp1 = 0 ;
9328 int res1 = 0 ;
9329 PyObject *swig_obj[1] ;
9330
9331 if (!args) SWIG_fail;
9332 swig_obj[0] = args;
9333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9334 if (!SWIG_IsOK(res1)) {
9335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetPosition" "', expected argument " "1"" of type '" "wxRect2D *""'");
9336 }
9337 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9338 {
9339 result = (arg1)->GetPosition();
9340 if (PyErr_Occurred()) SWIG_fail;
9341 }
9342 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9343 return resultobj;
9344 fail:
9345 return NULL;
9346 }
9347
9348
9349 SWIGINTERN PyObject *_wrap_Rect2D_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9350 PyObject *resultobj = 0;
9351 wxRect2D *arg1 = (wxRect2D *) 0 ;
9352 wxSize result;
9353 void *argp1 = 0 ;
9354 int res1 = 0 ;
9355 PyObject *swig_obj[1] ;
9356
9357 if (!args) SWIG_fail;
9358 swig_obj[0] = args;
9359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9360 if (!SWIG_IsOK(res1)) {
9361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetSize" "', expected argument " "1"" of type '" "wxRect2D *""'");
9362 }
9363 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9364 {
9365 result = (arg1)->GetSize();
9366 if (PyErr_Occurred()) SWIG_fail;
9367 }
9368 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
9369 return resultobj;
9370 fail:
9371 return NULL;
9372 }
9373
9374
9375 SWIGINTERN PyObject *_wrap_Rect2D_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9376 PyObject *resultobj = 0;
9377 wxRect2D *arg1 = (wxRect2D *) 0 ;
9378 wxDouble result;
9379 void *argp1 = 0 ;
9380 int res1 = 0 ;
9381 PyObject *swig_obj[1] ;
9382
9383 if (!args) SWIG_fail;
9384 swig_obj[0] = args;
9385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9386 if (!SWIG_IsOK(res1)) {
9387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeft" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9388 }
9389 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9390 {
9391 result = ((wxRect2D const *)arg1)->GetLeft();
9392 if (PyErr_Occurred()) SWIG_fail;
9393 }
9394 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9395 return resultobj;
9396 fail:
9397 return NULL;
9398 }
9399
9400
9401 SWIGINTERN PyObject *_wrap_Rect2D_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9402 PyObject *resultobj = 0;
9403 wxRect2D *arg1 = (wxRect2D *) 0 ;
9404 wxDouble arg2 ;
9405 void *argp1 = 0 ;
9406 int res1 = 0 ;
9407 void *argp2 ;
9408 int res2 = 0 ;
9409 PyObject * obj0 = 0 ;
9410 PyObject * obj1 = 0 ;
9411 char * kwnames[] = {
9412 (char *) "self",(char *) "n", NULL
9413 };
9414
9415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
9416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9417 if (!SWIG_IsOK(res1)) {
9418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeft" "', expected argument " "1"" of type '" "wxRect2D *""'");
9419 }
9420 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9421 {
9422 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9423 if (!SWIG_IsOK(res2)) {
9424 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetLeft" "', expected argument " "2"" of type '" "wxDouble""'");
9425 }
9426 if (!argp2) {
9427 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetLeft" "', expected argument " "2"" of type '" "wxDouble""'");
9428 } else {
9429 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9430 arg2 = *temp;
9431 if (SWIG_IsNewObj(res2)) delete temp;
9432 }
9433 }
9434 {
9435 (arg1)->SetLeft(arg2);
9436 if (PyErr_Occurred()) SWIG_fail;
9437 }
9438 resultobj = SWIG_Py_Void();
9439 return resultobj;
9440 fail:
9441 return NULL;
9442 }
9443
9444
9445 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9446 PyObject *resultobj = 0;
9447 wxRect2D *arg1 = (wxRect2D *) 0 ;
9448 wxDouble arg2 ;
9449 void *argp1 = 0 ;
9450 int res1 = 0 ;
9451 void *argp2 ;
9452 int res2 = 0 ;
9453 PyObject * obj0 = 0 ;
9454 PyObject * obj1 = 0 ;
9455 char * kwnames[] = {
9456 (char *) "self",(char *) "n", NULL
9457 };
9458
9459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftTo",kwnames,&obj0,&obj1)) SWIG_fail;
9460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9461 if (!SWIG_IsOK(res1)) {
9462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9463 }
9464 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9465 {
9466 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9467 if (!SWIG_IsOK(res2)) {
9468 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveLeftTo" "', expected argument " "2"" of type '" "wxDouble""'");
9469 }
9470 if (!argp2) {
9471 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveLeftTo" "', expected argument " "2"" of type '" "wxDouble""'");
9472 } else {
9473 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9474 arg2 = *temp;
9475 if (SWIG_IsNewObj(res2)) delete temp;
9476 }
9477 }
9478 {
9479 (arg1)->MoveLeftTo(arg2);
9480 if (PyErr_Occurred()) SWIG_fail;
9481 }
9482 resultobj = SWIG_Py_Void();
9483 return resultobj;
9484 fail:
9485 return NULL;
9486 }
9487
9488
9489 SWIGINTERN PyObject *_wrap_Rect2D_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9490 PyObject *resultobj = 0;
9491 wxRect2D *arg1 = (wxRect2D *) 0 ;
9492 wxDouble result;
9493 void *argp1 = 0 ;
9494 int res1 = 0 ;
9495 PyObject *swig_obj[1] ;
9496
9497 if (!args) SWIG_fail;
9498 swig_obj[0] = args;
9499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9500 if (!SWIG_IsOK(res1)) {
9501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9502 }
9503 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9504 {
9505 result = ((wxRect2D const *)arg1)->GetTop();
9506 if (PyErr_Occurred()) SWIG_fail;
9507 }
9508 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9509 return resultobj;
9510 fail:
9511 return NULL;
9512 }
9513
9514
9515 SWIGINTERN PyObject *_wrap_Rect2D_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9516 PyObject *resultobj = 0;
9517 wxRect2D *arg1 = (wxRect2D *) 0 ;
9518 wxDouble arg2 ;
9519 void *argp1 = 0 ;
9520 int res1 = 0 ;
9521 void *argp2 ;
9522 int res2 = 0 ;
9523 PyObject * obj0 = 0 ;
9524 PyObject * obj1 = 0 ;
9525 char * kwnames[] = {
9526 (char *) "self",(char *) "n", NULL
9527 };
9528
9529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
9530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9531 if (!SWIG_IsOK(res1)) {
9532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9533 }
9534 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9535 {
9536 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9537 if (!SWIG_IsOK(res2)) {
9538 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetTop" "', expected argument " "2"" of type '" "wxDouble""'");
9539 }
9540 if (!argp2) {
9541 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetTop" "', expected argument " "2"" of type '" "wxDouble""'");
9542 } else {
9543 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9544 arg2 = *temp;
9545 if (SWIG_IsNewObj(res2)) delete temp;
9546 }
9547 }
9548 {
9549 (arg1)->SetTop(arg2);
9550 if (PyErr_Occurred()) SWIG_fail;
9551 }
9552 resultobj = SWIG_Py_Void();
9553 return resultobj;
9554 fail:
9555 return NULL;
9556 }
9557
9558
9559 SWIGINTERN PyObject *_wrap_Rect2D_MoveTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9560 PyObject *resultobj = 0;
9561 wxRect2D *arg1 = (wxRect2D *) 0 ;
9562 wxDouble arg2 ;
9563 void *argp1 = 0 ;
9564 int res1 = 0 ;
9565 void *argp2 ;
9566 int res2 = 0 ;
9567 PyObject * obj0 = 0 ;
9568 PyObject * obj1 = 0 ;
9569 char * kwnames[] = {
9570 (char *) "self",(char *) "n", NULL
9571 };
9572
9573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
9574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9575 if (!SWIG_IsOK(res1)) {
9576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9577 }
9578 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9579 {
9580 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9581 if (!SWIG_IsOK(res2)) {
9582 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveTopTo" "', expected argument " "2"" of type '" "wxDouble""'");
9583 }
9584 if (!argp2) {
9585 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveTopTo" "', expected argument " "2"" of type '" "wxDouble""'");
9586 } else {
9587 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9588 arg2 = *temp;
9589 if (SWIG_IsNewObj(res2)) delete temp;
9590 }
9591 }
9592 {
9593 (arg1)->MoveTopTo(arg2);
9594 if (PyErr_Occurred()) SWIG_fail;
9595 }
9596 resultobj = SWIG_Py_Void();
9597 return resultobj;
9598 fail:
9599 return NULL;
9600 }
9601
9602
9603 SWIGINTERN PyObject *_wrap_Rect2D_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9604 PyObject *resultobj = 0;
9605 wxRect2D *arg1 = (wxRect2D *) 0 ;
9606 wxDouble result;
9607 void *argp1 = 0 ;
9608 int res1 = 0 ;
9609 PyObject *swig_obj[1] ;
9610
9611 if (!args) SWIG_fail;
9612 swig_obj[0] = args;
9613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9614 if (!SWIG_IsOK(res1)) {
9615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9616 }
9617 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9618 {
9619 result = ((wxRect2D const *)arg1)->GetBottom();
9620 if (PyErr_Occurred()) SWIG_fail;
9621 }
9622 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9623 return resultobj;
9624 fail:
9625 return NULL;
9626 }
9627
9628
9629 SWIGINTERN PyObject *_wrap_Rect2D_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9630 PyObject *resultobj = 0;
9631 wxRect2D *arg1 = (wxRect2D *) 0 ;
9632 wxDouble arg2 ;
9633 void *argp1 = 0 ;
9634 int res1 = 0 ;
9635 void *argp2 ;
9636 int res2 = 0 ;
9637 PyObject * obj0 = 0 ;
9638 PyObject * obj1 = 0 ;
9639 char * kwnames[] = {
9640 (char *) "self",(char *) "n", NULL
9641 };
9642
9643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
9644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9645 if (!SWIG_IsOK(res1)) {
9646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
9647 }
9648 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9649 {
9650 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9651 if (!SWIG_IsOK(res2)) {
9652 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetBottom" "', expected argument " "2"" of type '" "wxDouble""'");
9653 }
9654 if (!argp2) {
9655 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetBottom" "', expected argument " "2"" of type '" "wxDouble""'");
9656 } else {
9657 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9658 arg2 = *temp;
9659 if (SWIG_IsNewObj(res2)) delete temp;
9660 }
9661 }
9662 {
9663 (arg1)->SetBottom(arg2);
9664 if (PyErr_Occurred()) SWIG_fail;
9665 }
9666 resultobj = SWIG_Py_Void();
9667 return resultobj;
9668 fail:
9669 return NULL;
9670 }
9671
9672
9673 SWIGINTERN PyObject *_wrap_Rect2D_MoveBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9674 PyObject *resultobj = 0;
9675 wxRect2D *arg1 = (wxRect2D *) 0 ;
9676 wxDouble arg2 ;
9677 void *argp1 = 0 ;
9678 int res1 = 0 ;
9679 void *argp2 ;
9680 int res2 = 0 ;
9681 PyObject * obj0 = 0 ;
9682 PyObject * obj1 = 0 ;
9683 char * kwnames[] = {
9684 (char *) "self",(char *) "n", NULL
9685 };
9686
9687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
9688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9689 if (!SWIG_IsOK(res1)) {
9690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9691 }
9692 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9693 {
9694 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9695 if (!SWIG_IsOK(res2)) {
9696 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveBottomTo" "', expected argument " "2"" of type '" "wxDouble""'");
9697 }
9698 if (!argp2) {
9699 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveBottomTo" "', expected argument " "2"" of type '" "wxDouble""'");
9700 } else {
9701 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9702 arg2 = *temp;
9703 if (SWIG_IsNewObj(res2)) delete temp;
9704 }
9705 }
9706 {
9707 (arg1)->MoveBottomTo(arg2);
9708 if (PyErr_Occurred()) SWIG_fail;
9709 }
9710 resultobj = SWIG_Py_Void();
9711 return resultobj;
9712 fail:
9713 return NULL;
9714 }
9715
9716
9717 SWIGINTERN PyObject *_wrap_Rect2D_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9718 PyObject *resultobj = 0;
9719 wxRect2D *arg1 = (wxRect2D *) 0 ;
9720 wxDouble result;
9721 void *argp1 = 0 ;
9722 int res1 = 0 ;
9723 PyObject *swig_obj[1] ;
9724
9725 if (!args) SWIG_fail;
9726 swig_obj[0] = args;
9727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9728 if (!SWIG_IsOK(res1)) {
9729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRight" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9730 }
9731 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9732 {
9733 result = ((wxRect2D const *)arg1)->GetRight();
9734 if (PyErr_Occurred()) SWIG_fail;
9735 }
9736 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9737 return resultobj;
9738 fail:
9739 return NULL;
9740 }
9741
9742
9743 SWIGINTERN PyObject *_wrap_Rect2D_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9744 PyObject *resultobj = 0;
9745 wxRect2D *arg1 = (wxRect2D *) 0 ;
9746 wxDouble arg2 ;
9747 void *argp1 = 0 ;
9748 int res1 = 0 ;
9749 void *argp2 ;
9750 int res2 = 0 ;
9751 PyObject * obj0 = 0 ;
9752 PyObject * obj1 = 0 ;
9753 char * kwnames[] = {
9754 (char *) "self",(char *) "n", NULL
9755 };
9756
9757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
9758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9759 if (!SWIG_IsOK(res1)) {
9760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRight" "', expected argument " "1"" of type '" "wxRect2D *""'");
9761 }
9762 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9763 {
9764 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9765 if (!SWIG_IsOK(res2)) {
9766 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetRight" "', expected argument " "2"" of type '" "wxDouble""'");
9767 }
9768 if (!argp2) {
9769 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetRight" "', expected argument " "2"" of type '" "wxDouble""'");
9770 } else {
9771 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9772 arg2 = *temp;
9773 if (SWIG_IsNewObj(res2)) delete temp;
9774 }
9775 }
9776 {
9777 (arg1)->SetRight(arg2);
9778 if (PyErr_Occurred()) SWIG_fail;
9779 }
9780 resultobj = SWIG_Py_Void();
9781 return resultobj;
9782 fail:
9783 return NULL;
9784 }
9785
9786
9787 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9788 PyObject *resultobj = 0;
9789 wxRect2D *arg1 = (wxRect2D *) 0 ;
9790 wxDouble arg2 ;
9791 void *argp1 = 0 ;
9792 int res1 = 0 ;
9793 void *argp2 ;
9794 int res2 = 0 ;
9795 PyObject * obj0 = 0 ;
9796 PyObject * obj1 = 0 ;
9797 char * kwnames[] = {
9798 (char *) "self",(char *) "n", NULL
9799 };
9800
9801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightTo",kwnames,&obj0,&obj1)) SWIG_fail;
9802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9803 if (!SWIG_IsOK(res1)) {
9804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9805 }
9806 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9807 {
9808 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9809 if (!SWIG_IsOK(res2)) {
9810 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveRightTo" "', expected argument " "2"" of type '" "wxDouble""'");
9811 }
9812 if (!argp2) {
9813 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveRightTo" "', expected argument " "2"" of type '" "wxDouble""'");
9814 } else {
9815 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9816 arg2 = *temp;
9817 if (SWIG_IsNewObj(res2)) delete temp;
9818 }
9819 }
9820 {
9821 (arg1)->MoveRightTo(arg2);
9822 if (PyErr_Occurred()) SWIG_fail;
9823 }
9824 resultobj = SWIG_Py_Void();
9825 return resultobj;
9826 fail:
9827 return NULL;
9828 }
9829
9830
9831 SWIGINTERN PyObject *_wrap_Rect2D_GetLeftTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9832 PyObject *resultobj = 0;
9833 wxRect2D *arg1 = (wxRect2D *) 0 ;
9834 wxPoint2D result;
9835 void *argp1 = 0 ;
9836 int res1 = 0 ;
9837 PyObject *swig_obj[1] ;
9838
9839 if (!args) SWIG_fail;
9840 swig_obj[0] = args;
9841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9842 if (!SWIG_IsOK(res1)) {
9843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeftTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9844 }
9845 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9846 {
9847 result = ((wxRect2D const *)arg1)->GetLeftTop();
9848 if (PyErr_Occurred()) SWIG_fail;
9849 }
9850 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9851 return resultobj;
9852 fail:
9853 return NULL;
9854 }
9855
9856
9857 SWIGINTERN PyObject *_wrap_Rect2D_SetLeftTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9858 PyObject *resultobj = 0;
9859 wxRect2D *arg1 = (wxRect2D *) 0 ;
9860 wxPoint2D *arg2 = 0 ;
9861 void *argp1 = 0 ;
9862 int res1 = 0 ;
9863 wxPoint2D temp2 ;
9864 PyObject * obj0 = 0 ;
9865 PyObject * obj1 = 0 ;
9866 char * kwnames[] = {
9867 (char *) "self",(char *) "pt", NULL
9868 };
9869
9870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeftTop",kwnames,&obj0,&obj1)) SWIG_fail;
9871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9872 if (!SWIG_IsOK(res1)) {
9873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeftTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9874 }
9875 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9876 {
9877 arg2 = &temp2;
9878 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9879 }
9880 {
9881 (arg1)->SetLeftTop((wxPoint2D const &)*arg2);
9882 if (PyErr_Occurred()) SWIG_fail;
9883 }
9884 resultobj = SWIG_Py_Void();
9885 return resultobj;
9886 fail:
9887 return NULL;
9888 }
9889
9890
9891 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9892 PyObject *resultobj = 0;
9893 wxRect2D *arg1 = (wxRect2D *) 0 ;
9894 wxPoint2D *arg2 = 0 ;
9895 void *argp1 = 0 ;
9896 int res1 = 0 ;
9897 wxPoint2D temp2 ;
9898 PyObject * obj0 = 0 ;
9899 PyObject * obj1 = 0 ;
9900 char * kwnames[] = {
9901 (char *) "self",(char *) "pt", NULL
9902 };
9903
9904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
9905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9906 if (!SWIG_IsOK(res1)) {
9907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9908 }
9909 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9910 {
9911 arg2 = &temp2;
9912 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9913 }
9914 {
9915 (arg1)->MoveLeftTopTo((wxPoint2D const &)*arg2);
9916 if (PyErr_Occurred()) SWIG_fail;
9917 }
9918 resultobj = SWIG_Py_Void();
9919 return resultobj;
9920 fail:
9921 return NULL;
9922 }
9923
9924
9925 SWIGINTERN PyObject *_wrap_Rect2D_GetLeftBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9926 PyObject *resultobj = 0;
9927 wxRect2D *arg1 = (wxRect2D *) 0 ;
9928 wxPoint2D result;
9929 void *argp1 = 0 ;
9930 int res1 = 0 ;
9931 PyObject *swig_obj[1] ;
9932
9933 if (!args) SWIG_fail;
9934 swig_obj[0] = args;
9935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9936 if (!SWIG_IsOK(res1)) {
9937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeftBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9938 }
9939 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9940 {
9941 result = ((wxRect2D const *)arg1)->GetLeftBottom();
9942 if (PyErr_Occurred()) SWIG_fail;
9943 }
9944 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9945 return resultobj;
9946 fail:
9947 return NULL;
9948 }
9949
9950
9951 SWIGINTERN PyObject *_wrap_Rect2D_SetLeftBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9952 PyObject *resultobj = 0;
9953 wxRect2D *arg1 = (wxRect2D *) 0 ;
9954 wxPoint2D *arg2 = 0 ;
9955 void *argp1 = 0 ;
9956 int res1 = 0 ;
9957 wxPoint2D temp2 ;
9958 PyObject * obj0 = 0 ;
9959 PyObject * obj1 = 0 ;
9960 char * kwnames[] = {
9961 (char *) "self",(char *) "pt", NULL
9962 };
9963
9964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeftBottom",kwnames,&obj0,&obj1)) SWIG_fail;
9965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9966 if (!SWIG_IsOK(res1)) {
9967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeftBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
9968 }
9969 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9970 {
9971 arg2 = &temp2;
9972 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9973 }
9974 {
9975 (arg1)->SetLeftBottom((wxPoint2D const &)*arg2);
9976 if (PyErr_Occurred()) SWIG_fail;
9977 }
9978 resultobj = SWIG_Py_Void();
9979 return resultobj;
9980 fail:
9981 return NULL;
9982 }
9983
9984
9985 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9986 PyObject *resultobj = 0;
9987 wxRect2D *arg1 = (wxRect2D *) 0 ;
9988 wxPoint2D *arg2 = 0 ;
9989 void *argp1 = 0 ;
9990 int res1 = 0 ;
9991 wxPoint2D temp2 ;
9992 PyObject * obj0 = 0 ;
9993 PyObject * obj1 = 0 ;
9994 char * kwnames[] = {
9995 (char *) "self",(char *) "pt", NULL
9996 };
9997
9998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
9999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10000 if (!SWIG_IsOK(res1)) {
10001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10002 }
10003 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10004 {
10005 arg2 = &temp2;
10006 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10007 }
10008 {
10009 (arg1)->MoveLeftBottomTo((wxPoint2D const &)*arg2);
10010 if (PyErr_Occurred()) SWIG_fail;
10011 }
10012 resultobj = SWIG_Py_Void();
10013 return resultobj;
10014 fail:
10015 return NULL;
10016 }
10017
10018
10019 SWIGINTERN PyObject *_wrap_Rect2D_GetRightTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10020 PyObject *resultobj = 0;
10021 wxRect2D *arg1 = (wxRect2D *) 0 ;
10022 wxPoint2D result;
10023 void *argp1 = 0 ;
10024 int res1 = 0 ;
10025 PyObject *swig_obj[1] ;
10026
10027 if (!args) SWIG_fail;
10028 swig_obj[0] = args;
10029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10030 if (!SWIG_IsOK(res1)) {
10031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRightTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10032 }
10033 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10034 {
10035 result = ((wxRect2D const *)arg1)->GetRightTop();
10036 if (PyErr_Occurred()) SWIG_fail;
10037 }
10038 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10039 return resultobj;
10040 fail:
10041 return NULL;
10042 }
10043
10044
10045 SWIGINTERN PyObject *_wrap_Rect2D_SetRightTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10046 PyObject *resultobj = 0;
10047 wxRect2D *arg1 = (wxRect2D *) 0 ;
10048 wxPoint2D *arg2 = 0 ;
10049 void *argp1 = 0 ;
10050 int res1 = 0 ;
10051 wxPoint2D temp2 ;
10052 PyObject * obj0 = 0 ;
10053 PyObject * obj1 = 0 ;
10054 char * kwnames[] = {
10055 (char *) "self",(char *) "pt", NULL
10056 };
10057
10058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRightTop",kwnames,&obj0,&obj1)) SWIG_fail;
10059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10060 if (!SWIG_IsOK(res1)) {
10061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRightTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
10062 }
10063 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10064 {
10065 arg2 = &temp2;
10066 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10067 }
10068 {
10069 (arg1)->SetRightTop((wxPoint2D const &)*arg2);
10070 if (PyErr_Occurred()) SWIG_fail;
10071 }
10072 resultobj = SWIG_Py_Void();
10073 return resultobj;
10074 fail:
10075 return NULL;
10076 }
10077
10078
10079 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10080 PyObject *resultobj = 0;
10081 wxRect2D *arg1 = (wxRect2D *) 0 ;
10082 wxPoint2D *arg2 = 0 ;
10083 void *argp1 = 0 ;
10084 int res1 = 0 ;
10085 wxPoint2D temp2 ;
10086 PyObject * obj0 = 0 ;
10087 PyObject * obj1 = 0 ;
10088 char * kwnames[] = {
10089 (char *) "self",(char *) "pt", NULL
10090 };
10091
10092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
10093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10094 if (!SWIG_IsOK(res1)) {
10095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10096 }
10097 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10098 {
10099 arg2 = &temp2;
10100 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10101 }
10102 {
10103 (arg1)->MoveRightTopTo((wxPoint2D const &)*arg2);
10104 if (PyErr_Occurred()) SWIG_fail;
10105 }
10106 resultobj = SWIG_Py_Void();
10107 return resultobj;
10108 fail:
10109 return NULL;
10110 }
10111
10112
10113 SWIGINTERN PyObject *_wrap_Rect2D_GetRightBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10114 PyObject *resultobj = 0;
10115 wxRect2D *arg1 = (wxRect2D *) 0 ;
10116 wxPoint2D result;
10117 void *argp1 = 0 ;
10118 int res1 = 0 ;
10119 PyObject *swig_obj[1] ;
10120
10121 if (!args) SWIG_fail;
10122 swig_obj[0] = args;
10123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10124 if (!SWIG_IsOK(res1)) {
10125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRightBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10126 }
10127 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10128 {
10129 result = ((wxRect2D const *)arg1)->GetRightBottom();
10130 if (PyErr_Occurred()) SWIG_fail;
10131 }
10132 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10133 return resultobj;
10134 fail:
10135 return NULL;
10136 }
10137
10138
10139 SWIGINTERN PyObject *_wrap_Rect2D_SetRightBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10140 PyObject *resultobj = 0;
10141 wxRect2D *arg1 = (wxRect2D *) 0 ;
10142 wxPoint2D *arg2 = 0 ;
10143 void *argp1 = 0 ;
10144 int res1 = 0 ;
10145 wxPoint2D temp2 ;
10146 PyObject * obj0 = 0 ;
10147 PyObject * obj1 = 0 ;
10148 char * kwnames[] = {
10149 (char *) "self",(char *) "pt", NULL
10150 };
10151
10152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRightBottom",kwnames,&obj0,&obj1)) SWIG_fail;
10153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10154 if (!SWIG_IsOK(res1)) {
10155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRightBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
10156 }
10157 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10158 {
10159 arg2 = &temp2;
10160 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10161 }
10162 {
10163 (arg1)->SetRightBottom((wxPoint2D const &)*arg2);
10164 if (PyErr_Occurred()) SWIG_fail;
10165 }
10166 resultobj = SWIG_Py_Void();
10167 return resultobj;
10168 fail:
10169 return NULL;
10170 }
10171
10172
10173 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10174 PyObject *resultobj = 0;
10175 wxRect2D *arg1 = (wxRect2D *) 0 ;
10176 wxPoint2D *arg2 = 0 ;
10177 void *argp1 = 0 ;
10178 int res1 = 0 ;
10179 wxPoint2D temp2 ;
10180 PyObject * obj0 = 0 ;
10181 PyObject * obj1 = 0 ;
10182 char * kwnames[] = {
10183 (char *) "self",(char *) "pt", NULL
10184 };
10185
10186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
10187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10188 if (!SWIG_IsOK(res1)) {
10189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10190 }
10191 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10192 {
10193 arg2 = &temp2;
10194 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10195 }
10196 {
10197 (arg1)->MoveRightBottomTo((wxPoint2D const &)*arg2);
10198 if (PyErr_Occurred()) SWIG_fail;
10199 }
10200 resultobj = SWIG_Py_Void();
10201 return resultobj;
10202 fail:
10203 return NULL;
10204 }
10205
10206
10207 SWIGINTERN PyObject *_wrap_Rect2D_GetCentre(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10208 PyObject *resultobj = 0;
10209 wxRect2D *arg1 = (wxRect2D *) 0 ;
10210 wxPoint2D result;
10211 void *argp1 = 0 ;
10212 int res1 = 0 ;
10213 PyObject *swig_obj[1] ;
10214
10215 if (!args) SWIG_fail;
10216 swig_obj[0] = args;
10217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10218 if (!SWIG_IsOK(res1)) {
10219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetCentre" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10220 }
10221 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10222 {
10223 result = ((wxRect2D const *)arg1)->GetCentre();
10224 if (PyErr_Occurred()) SWIG_fail;
10225 }
10226 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10227 return resultobj;
10228 fail:
10229 return NULL;
10230 }
10231
10232
10233 SWIGINTERN PyObject *_wrap_Rect2D_SetCentre(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10234 PyObject *resultobj = 0;
10235 wxRect2D *arg1 = (wxRect2D *) 0 ;
10236 wxPoint2D *arg2 = 0 ;
10237 void *argp1 = 0 ;
10238 int res1 = 0 ;
10239 wxPoint2D temp2 ;
10240 PyObject * obj0 = 0 ;
10241 PyObject * obj1 = 0 ;
10242 char * kwnames[] = {
10243 (char *) "self",(char *) "pt", NULL
10244 };
10245
10246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetCentre",kwnames,&obj0,&obj1)) SWIG_fail;
10247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10248 if (!SWIG_IsOK(res1)) {
10249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetCentre" "', expected argument " "1"" of type '" "wxRect2D *""'");
10250 }
10251 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10252 {
10253 arg2 = &temp2;
10254 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10255 }
10256 {
10257 (arg1)->SetCentre((wxPoint2D const &)*arg2);
10258 if (PyErr_Occurred()) SWIG_fail;
10259 }
10260 resultobj = SWIG_Py_Void();
10261 return resultobj;
10262 fail:
10263 return NULL;
10264 }
10265
10266
10267 SWIGINTERN PyObject *_wrap_Rect2D_MoveCentreTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10268 PyObject *resultobj = 0;
10269 wxRect2D *arg1 = (wxRect2D *) 0 ;
10270 wxPoint2D *arg2 = 0 ;
10271 void *argp1 = 0 ;
10272 int res1 = 0 ;
10273 wxPoint2D temp2 ;
10274 PyObject * obj0 = 0 ;
10275 PyObject * obj1 = 0 ;
10276 char * kwnames[] = {
10277 (char *) "self",(char *) "pt", NULL
10278 };
10279
10280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveCentreTo",kwnames,&obj0,&obj1)) SWIG_fail;
10281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10282 if (!SWIG_IsOK(res1)) {
10283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveCentreTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10284 }
10285 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10286 {
10287 arg2 = &temp2;
10288 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10289 }
10290 {
10291 (arg1)->MoveCentreTo((wxPoint2D const &)*arg2);
10292 if (PyErr_Occurred()) SWIG_fail;
10293 }
10294 resultobj = SWIG_Py_Void();
10295 return resultobj;
10296 fail:
10297 return NULL;
10298 }
10299
10300
10301 SWIGINTERN PyObject *_wrap_Rect2D_GetOutcode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10302 PyObject *resultobj = 0;
10303 wxRect2D *arg1 = (wxRect2D *) 0 ;
10304 wxPoint2D *arg2 = 0 ;
10305 wxOutCode result;
10306 void *argp1 = 0 ;
10307 int res1 = 0 ;
10308 wxPoint2D temp2 ;
10309 PyObject * obj0 = 0 ;
10310 PyObject * obj1 = 0 ;
10311 char * kwnames[] = {
10312 (char *) "self",(char *) "pt", NULL
10313 };
10314
10315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_GetOutcode",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_GetOutcode" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10319 }
10320 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10321 {
10322 arg2 = &temp2;
10323 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10324 }
10325 {
10326 result = (wxOutCode)((wxRect2D const *)arg1)->GetOutcode((wxPoint2D const &)*arg2);
10327 if (PyErr_Occurred()) SWIG_fail;
10328 }
10329 resultobj = SWIG_From_int(static_cast< int >(result));
10330 return resultobj;
10331 fail:
10332 return NULL;
10333 }
10334
10335
10336 SWIGINTERN PyObject *_wrap_Rect2D_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10337 PyObject *resultobj = 0;
10338 wxRect2D *arg1 = (wxRect2D *) 0 ;
10339 wxPoint2D *arg2 = 0 ;
10340 bool result;
10341 void *argp1 = 0 ;
10342 int res1 = 0 ;
10343 wxPoint2D temp2 ;
10344 PyObject * obj0 = 0 ;
10345 PyObject * obj1 = 0 ;
10346 char * kwnames[] = {
10347 (char *) "self",(char *) "pt", NULL
10348 };
10349
10350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
10351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10352 if (!SWIG_IsOK(res1)) {
10353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Contains" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10354 }
10355 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10356 {
10357 arg2 = &temp2;
10358 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10359 }
10360 {
10361 result = (bool)((wxRect2D const *)arg1)->Contains((wxPoint2D const &)*arg2);
10362 if (PyErr_Occurred()) SWIG_fail;
10363 }
10364 {
10365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10366 }
10367 return resultobj;
10368 fail:
10369 return NULL;
10370 }
10371
10372
10373 SWIGINTERN PyObject *_wrap_Rect2D_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10374 PyObject *resultobj = 0;
10375 wxRect2D *arg1 = (wxRect2D *) 0 ;
10376 wxRect2D *arg2 = 0 ;
10377 bool result;
10378 void *argp1 = 0 ;
10379 int res1 = 0 ;
10380 wxRect2D temp2 ;
10381 PyObject * obj0 = 0 ;
10382 PyObject * obj1 = 0 ;
10383 char * kwnames[] = {
10384 (char *) "self",(char *) "rect", NULL
10385 };
10386
10387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
10388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10389 if (!SWIG_IsOK(res1)) {
10390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_ContainsRect" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10391 }
10392 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10393 {
10394 arg2 = &temp2;
10395 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10396 }
10397 {
10398 result = (bool)((wxRect2D const *)arg1)->Contains((wxRect2D const &)*arg2);
10399 if (PyErr_Occurred()) SWIG_fail;
10400 }
10401 {
10402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10403 }
10404 return resultobj;
10405 fail:
10406 return NULL;
10407 }
10408
10409
10410 SWIGINTERN PyObject *_wrap_Rect2D_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10411 PyObject *resultobj = 0;
10412 wxRect2D *arg1 = (wxRect2D *) 0 ;
10413 bool result;
10414 void *argp1 = 0 ;
10415 int res1 = 0 ;
10416 PyObject *swig_obj[1] ;
10417
10418 if (!args) SWIG_fail;
10419 swig_obj[0] = args;
10420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10421 if (!SWIG_IsOK(res1)) {
10422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_IsEmpty" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10423 }
10424 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10425 {
10426 result = (bool)((wxRect2D const *)arg1)->IsEmpty();
10427 if (PyErr_Occurred()) SWIG_fail;
10428 }
10429 {
10430 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10431 }
10432 return resultobj;
10433 fail:
10434 return NULL;
10435 }
10436
10437
10438 SWIGINTERN PyObject *_wrap_Rect2D_HaveEqualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10439 PyObject *resultobj = 0;
10440 wxRect2D *arg1 = (wxRect2D *) 0 ;
10441 wxRect2D *arg2 = 0 ;
10442 bool result;
10443 void *argp1 = 0 ;
10444 int res1 = 0 ;
10445 wxRect2D temp2 ;
10446 PyObject * obj0 = 0 ;
10447 PyObject * obj1 = 0 ;
10448 char * kwnames[] = {
10449 (char *) "self",(char *) "rect", NULL
10450 };
10451
10452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_HaveEqualSize",kwnames,&obj0,&obj1)) SWIG_fail;
10453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10454 if (!SWIG_IsOK(res1)) {
10455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_HaveEqualSize" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10456 }
10457 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10458 {
10459 arg2 = &temp2;
10460 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10461 }
10462 {
10463 result = (bool)((wxRect2D const *)arg1)->HaveEqualSize((wxRect2D const &)*arg2);
10464 if (PyErr_Occurred()) SWIG_fail;
10465 }
10466 {
10467 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10468 }
10469 return resultobj;
10470 fail:
10471 return NULL;
10472 }
10473
10474
10475 SWIGINTERN PyObject *_wrap_Rect2D_Inset__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10476 PyObject *resultobj = 0;
10477 wxRect2D *arg1 = (wxRect2D *) 0 ;
10478 wxDouble arg2 ;
10479 wxDouble arg3 ;
10480 void *argp1 = 0 ;
10481 int res1 = 0 ;
10482 void *argp2 ;
10483 int res2 = 0 ;
10484 void *argp3 ;
10485 int res3 = 0 ;
10486
10487 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
10488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10489 if (!SWIG_IsOK(res1)) {
10490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Inset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10491 }
10492 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10493 {
10494 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10495 if (!SWIG_IsOK(res2)) {
10496 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10497 }
10498 if (!argp2) {
10499 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10500 } else {
10501 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10502 arg2 = *temp;
10503 if (SWIG_IsNewObj(res2)) delete temp;
10504 }
10505 }
10506 {
10507 res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
10508 if (!SWIG_IsOK(res3)) {
10509 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10510 }
10511 if (!argp3) {
10512 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10513 } else {
10514 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
10515 arg3 = *temp;
10516 if (SWIG_IsNewObj(res3)) delete temp;
10517 }
10518 }
10519 {
10520 (arg1)->Inset(arg2,arg3);
10521 if (PyErr_Occurred()) SWIG_fail;
10522 }
10523 resultobj = SWIG_Py_Void();
10524 return resultobj;
10525 fail:
10526 return NULL;
10527 }
10528
10529
10530 SWIGINTERN PyObject *_wrap_Rect2D_Inset__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10531 PyObject *resultobj = 0;
10532 wxRect2D *arg1 = (wxRect2D *) 0 ;
10533 wxDouble arg2 ;
10534 wxDouble arg3 ;
10535 wxDouble arg4 ;
10536 wxDouble arg5 ;
10537 void *argp1 = 0 ;
10538 int res1 = 0 ;
10539 void *argp2 ;
10540 int res2 = 0 ;
10541 void *argp3 ;
10542 int res3 = 0 ;
10543 void *argp4 ;
10544 int res4 = 0 ;
10545 void *argp5 ;
10546 int res5 = 0 ;
10547
10548 if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
10549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10550 if (!SWIG_IsOK(res1)) {
10551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Inset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10552 }
10553 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10554 {
10555 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10556 if (!SWIG_IsOK(res2)) {
10557 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10558 }
10559 if (!argp2) {
10560 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10561 } else {
10562 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10563 arg2 = *temp;
10564 if (SWIG_IsNewObj(res2)) delete temp;
10565 }
10566 }
10567 {
10568 res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
10569 if (!SWIG_IsOK(res3)) {
10570 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10571 }
10572 if (!argp3) {
10573 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10574 } else {
10575 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
10576 arg3 = *temp;
10577 if (SWIG_IsNewObj(res3)) delete temp;
10578 }
10579 }
10580 {
10581 res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
10582 if (!SWIG_IsOK(res4)) {
10583 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Rect2D_Inset" "', expected argument " "4"" of type '" "wxDouble""'");
10584 }
10585 if (!argp4) {
10586 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "4"" of type '" "wxDouble""'");
10587 } else {
10588 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
10589 arg4 = *temp;
10590 if (SWIG_IsNewObj(res4)) delete temp;
10591 }
10592 }
10593 {
10594 res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_wxDouble, 0 | 0);
10595 if (!SWIG_IsOK(res5)) {
10596 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Rect2D_Inset" "', expected argument " "5"" of type '" "wxDouble""'");
10597 }
10598 if (!argp5) {
10599 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "5"" of type '" "wxDouble""'");
10600 } else {
10601 wxDouble * temp = reinterpret_cast< wxDouble * >(argp5);
10602 arg5 = *temp;
10603 if (SWIG_IsNewObj(res5)) delete temp;
10604 }
10605 }
10606 {
10607 (arg1)->Inset(arg2,arg3,arg4,arg5);
10608 if (PyErr_Occurred()) SWIG_fail;
10609 }
10610 resultobj = SWIG_Py_Void();
10611 return resultobj;
10612 fail:
10613 return NULL;
10614 }
10615
10616
10617 SWIGINTERN PyObject *_wrap_Rect2D_Inset(PyObject *self, PyObject *args) {
10618 int argc;
10619 PyObject *argv[6];
10620
10621 if (!(argc = SWIG_Python_UnpackTuple(args,"Rect2D_Inset",0,5,argv))) SWIG_fail;
10622 --argc;
10623 if (argc == 3) {
10624 return _wrap_Rect2D_Inset__SWIG_0(self, argc, argv);
10625 }
10626 if (argc == 5) {
10627 return _wrap_Rect2D_Inset__SWIG_1(self, argc, argv);
10628 }
10629
10630 fail:
10631 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Rect2D_Inset'");
10632 return NULL;
10633 }
10634
10635
10636 SWIGINTERN PyObject *_wrap_Rect2D_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10637 PyObject *resultobj = 0;
10638 wxRect2D *arg1 = (wxRect2D *) 0 ;
10639 wxPoint2D *arg2 = 0 ;
10640 void *argp1 = 0 ;
10641 int res1 = 0 ;
10642 wxPoint2D temp2 ;
10643 PyObject * obj0 = 0 ;
10644 PyObject * obj1 = 0 ;
10645 char * kwnames[] = {
10646 (char *) "self",(char *) "pt", NULL
10647 };
10648
10649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
10650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10651 if (!SWIG_IsOK(res1)) {
10652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Offset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10653 }
10654 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10655 {
10656 arg2 = &temp2;
10657 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10658 }
10659 {
10660 (arg1)->Offset((wxPoint2D const &)*arg2);
10661 if (PyErr_Occurred()) SWIG_fail;
10662 }
10663 resultobj = SWIG_Py_Void();
10664 return resultobj;
10665 fail:
10666 return NULL;
10667 }
10668
10669
10670 SWIGINTERN PyObject *_wrap_Rect2D_ConstrainTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10671 PyObject *resultobj = 0;
10672 wxRect2D *arg1 = (wxRect2D *) 0 ;
10673 wxRect2D *arg2 = 0 ;
10674 void *argp1 = 0 ;
10675 int res1 = 0 ;
10676 wxRect2D temp2 ;
10677 PyObject * obj0 = 0 ;
10678 PyObject * obj1 = 0 ;
10679 char * kwnames[] = {
10680 (char *) "self",(char *) "rect", NULL
10681 };
10682
10683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_ConstrainTo",kwnames,&obj0,&obj1)) SWIG_fail;
10684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10685 if (!SWIG_IsOK(res1)) {
10686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_ConstrainTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10687 }
10688 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10689 {
10690 arg2 = &temp2;
10691 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10692 }
10693 {
10694 (arg1)->ConstrainTo((wxRect2D const &)*arg2);
10695 if (PyErr_Occurred()) SWIG_fail;
10696 }
10697 resultobj = SWIG_Py_Void();
10698 return resultobj;
10699 fail:
10700 return NULL;
10701 }
10702
10703
10704 SWIGINTERN PyObject *_wrap_Rect2D_Interpolate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10705 PyObject *resultobj = 0;
10706 wxRect2D *arg1 = (wxRect2D *) 0 ;
10707 int arg2 ;
10708 int arg3 ;
10709 wxPoint2D result;
10710 void *argp1 = 0 ;
10711 int res1 = 0 ;
10712 int val2 ;
10713 int ecode2 = 0 ;
10714 int val3 ;
10715 int ecode3 = 0 ;
10716 PyObject * obj0 = 0 ;
10717 PyObject * obj1 = 0 ;
10718 PyObject * obj2 = 0 ;
10719 char * kwnames[] = {
10720 (char *) "self",(char *) "widthfactor",(char *) "heightfactor", NULL
10721 };
10722
10723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect2D_Interpolate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10725 if (!SWIG_IsOK(res1)) {
10726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Interpolate" "', expected argument " "1"" of type '" "wxRect2D *""'");
10727 }
10728 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10729 ecode2 = SWIG_AsVal_int(obj1, &val2);
10730 if (!SWIG_IsOK(ecode2)) {
10731 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect2D_Interpolate" "', expected argument " "2"" of type '" "int""'");
10732 }
10733 arg2 = static_cast< int >(val2);
10734 ecode3 = SWIG_AsVal_int(obj2, &val3);
10735 if (!SWIG_IsOK(ecode3)) {
10736 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect2D_Interpolate" "', expected argument " "3"" of type '" "int""'");
10737 }
10738 arg3 = static_cast< int >(val3);
10739 {
10740 result = (arg1)->Interpolate(arg2,arg3);
10741 if (PyErr_Occurred()) SWIG_fail;
10742 }
10743 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10744 return resultobj;
10745 fail:
10746 return NULL;
10747 }
10748
10749
10750 SWIGINTERN PyObject *_wrap_Rect2D_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10751 PyObject *resultobj = 0;
10752 wxRect2D *arg1 = (wxRect2D *) 0 ;
10753 wxRect2D *arg2 = 0 ;
10754 void *argp1 = 0 ;
10755 int res1 = 0 ;
10756 wxRect2D temp2 ;
10757 PyObject * obj0 = 0 ;
10758 PyObject * obj1 = 0 ;
10759 char * kwnames[] = {
10760 (char *) "self",(char *) "otherRect", NULL
10761 };
10762
10763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
10764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10765 if (!SWIG_IsOK(res1)) {
10766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Intersect" "', expected argument " "1"" of type '" "wxRect2D *""'");
10767 }
10768 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10769 {
10770 arg2 = &temp2;
10771 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10772 }
10773 {
10774 (arg1)->Intersect((wxRect2D const &)*arg2);
10775 if (PyErr_Occurred()) SWIG_fail;
10776 }
10777 resultobj = SWIG_Py_Void();
10778 return resultobj;
10779 fail:
10780 return NULL;
10781 }
10782
10783
10784 SWIGINTERN PyObject *_wrap_Rect2D_CreateIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10785 PyObject *resultobj = 0;
10786 wxRect2D *arg1 = (wxRect2D *) 0 ;
10787 wxRect2D *arg2 = 0 ;
10788 wxRect2D result;
10789 void *argp1 = 0 ;
10790 int res1 = 0 ;
10791 wxRect2D temp2 ;
10792 PyObject * obj0 = 0 ;
10793 PyObject * obj1 = 0 ;
10794 char * kwnames[] = {
10795 (char *) "self",(char *) "otherRect", NULL
10796 };
10797
10798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_CreateIntersection",kwnames,&obj0,&obj1)) SWIG_fail;
10799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10800 if (!SWIG_IsOK(res1)) {
10801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_CreateIntersection" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10802 }
10803 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10804 {
10805 arg2 = &temp2;
10806 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10807 }
10808 {
10809 result = ((wxRect2D const *)arg1)->CreateIntersection((wxRect2D const &)*arg2);
10810 if (PyErr_Occurred()) SWIG_fail;
10811 }
10812 resultobj = SWIG_NewPointerObj((new wxRect2D(static_cast< const wxRect2D& >(result))), SWIGTYPE_p_wxRect2D, SWIG_POINTER_OWN | 0 );
10813 return resultobj;
10814 fail:
10815 return NULL;
10816 }
10817
10818
10819 SWIGINTERN PyObject *_wrap_Rect2D_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10820 PyObject *resultobj = 0;
10821 wxRect2D *arg1 = (wxRect2D *) 0 ;
10822 wxRect2D *arg2 = 0 ;
10823 bool result;
10824 void *argp1 = 0 ;
10825 int res1 = 0 ;
10826 wxRect2D temp2 ;
10827 PyObject * obj0 = 0 ;
10828 PyObject * obj1 = 0 ;
10829 char * kwnames[] = {
10830 (char *) "self",(char *) "rect", NULL
10831 };
10832
10833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
10834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10835 if (!SWIG_IsOK(res1)) {
10836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Intersects" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10837 }
10838 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10839 {
10840 arg2 = &temp2;
10841 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10842 }
10843 {
10844 result = (bool)((wxRect2D const *)arg1)->Intersects((wxRect2D const &)*arg2);
10845 if (PyErr_Occurred()) SWIG_fail;
10846 }
10847 {
10848 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10849 }
10850 return resultobj;
10851 fail:
10852 return NULL;
10853 }
10854
10855
10856 SWIGINTERN PyObject *_wrap_Rect2D_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10857 PyObject *resultobj = 0;
10858 wxRect2D *arg1 = (wxRect2D *) 0 ;
10859 wxRect2D *arg2 = 0 ;
10860 void *argp1 = 0 ;
10861 int res1 = 0 ;
10862 wxRect2D temp2 ;
10863 PyObject * obj0 = 0 ;
10864 PyObject * obj1 = 0 ;
10865 char * kwnames[] = {
10866 (char *) "self",(char *) "otherRect", NULL
10867 };
10868
10869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Union",kwnames,&obj0,&obj1)) SWIG_fail;
10870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10871 if (!SWIG_IsOK(res1)) {
10872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Union" "', expected argument " "1"" of type '" "wxRect2D *""'");
10873 }
10874 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10875 {
10876 arg2 = &temp2;
10877 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10878 }
10879 {
10880 (arg1)->Union((wxRect2D const &)*arg2);
10881 if (PyErr_Occurred()) SWIG_fail;
10882 }
10883 resultobj = SWIG_Py_Void();
10884 return resultobj;
10885 fail:
10886 return NULL;
10887 }
10888
10889
10890 SWIGINTERN PyObject *_wrap_Rect2D_CreateUnion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10891 PyObject *resultobj = 0;
10892 wxRect2D *arg1 = (wxRect2D *) 0 ;
10893 wxRect2D *arg2 = 0 ;
10894 wxRect2D result;
10895 void *argp1 = 0 ;
10896 int res1 = 0 ;
10897 wxRect2D temp2 ;
10898 PyObject * obj0 = 0 ;
10899 PyObject * obj1 = 0 ;
10900 char * kwnames[] = {
10901 (char *) "self",(char *) "otherRect", NULL
10902 };
10903
10904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_CreateUnion",kwnames,&obj0,&obj1)) SWIG_fail;
10905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10906 if (!SWIG_IsOK(res1)) {
10907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_CreateUnion" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10908 }
10909 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10910 {
10911 arg2 = &temp2;
10912 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10913 }
10914 {
10915 result = ((wxRect2D const *)arg1)->CreateUnion((wxRect2D const &)*arg2);
10916 if (PyErr_Occurred()) SWIG_fail;
10917 }
10918 resultobj = SWIG_NewPointerObj((new wxRect2D(static_cast< const wxRect2D& >(result))), SWIGTYPE_p_wxRect2D, SWIG_POINTER_OWN | 0 );
10919 return resultobj;
10920 fail:
10921 return NULL;
10922 }
10923
10924
10925 SWIGINTERN PyObject *_wrap_Rect2D_Scale__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10926 PyObject *resultobj = 0;
10927 wxRect2D *arg1 = (wxRect2D *) 0 ;
10928 wxDouble arg2 ;
10929 void *argp1 = 0 ;
10930 int res1 = 0 ;
10931 void *argp2 ;
10932 int res2 = 0 ;
10933
10934 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
10935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10936 if (!SWIG_IsOK(res1)) {
10937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Scale" "', expected argument " "1"" of type '" "wxRect2D *""'");
10938 }
10939 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10940 {
10941 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10942 if (!SWIG_IsOK(res2)) {
10943 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "wxDouble""'");
10944 }
10945 if (!argp2) {
10946 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "wxDouble""'");
10947 } else {
10948 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10949 arg2 = *temp;
10950 if (SWIG_IsNewObj(res2)) delete temp;
10951 }
10952 }
10953 {
10954 (arg1)->Scale(arg2);
10955 if (PyErr_Occurred()) SWIG_fail;
10956 }
10957 resultobj = SWIG_Py_Void();
10958 return resultobj;
10959 fail:
10960 return NULL;
10961 }
10962
10963
10964 SWIGINTERN PyObject *_wrap_Rect2D_Scale__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10965 PyObject *resultobj = 0;
10966 wxRect2D *arg1 = (wxRect2D *) 0 ;
10967 int arg2 ;
10968 int arg3 ;
10969 void *argp1 = 0 ;
10970 int res1 = 0 ;
10971 int val2 ;
10972 int ecode2 = 0 ;
10973 int val3 ;
10974 int ecode3 = 0 ;
10975
10976 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
10977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10978 if (!SWIG_IsOK(res1)) {
10979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Scale" "', expected argument " "1"" of type '" "wxRect2D *""'");
10980 }
10981 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10982 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10983 if (!SWIG_IsOK(ecode2)) {
10984 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "int""'");
10985 }
10986 arg2 = static_cast< int >(val2);
10987 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
10988 if (!SWIG_IsOK(ecode3)) {
10989 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect2D_Scale" "', expected argument " "3"" of type '" "int""'");
10990 }
10991 arg3 = static_cast< int >(val3);
10992 {
10993 (arg1)->Scale(arg2,arg3);
10994 if (PyErr_Occurred()) SWIG_fail;
10995 }
10996 resultobj = SWIG_Py_Void();
10997 return resultobj;
10998 fail:
10999 return NULL;
11000 }
11001
11002
11003 SWIGINTERN PyObject *_wrap_Rect2D_Scale(PyObject *self, PyObject *args) {
11004 int argc;
11005 PyObject *argv[4];
11006
11007 if (!(argc = SWIG_Python_UnpackTuple(args,"Rect2D_Scale",0,3,argv))) SWIG_fail;
11008 --argc;
11009 if (argc == 2) {
11010 return _wrap_Rect2D_Scale__SWIG_0(self, argc, argv);
11011 }
11012 if (argc == 3) {
11013 return _wrap_Rect2D_Scale__SWIG_1(self, argc, argv);
11014 }
11015
11016 fail:
11017 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Rect2D_Scale'");
11018 return NULL;
11019 }
11020
11021
11022 SWIGINTERN PyObject *_wrap_Rect2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11023 PyObject *resultobj = 0;
11024 wxRect2D *arg1 = (wxRect2D *) 0 ;
11025 PyObject *arg2 = (PyObject *) 0 ;
11026 bool result;
11027 void *argp1 = 0 ;
11028 int res1 = 0 ;
11029 PyObject * obj0 = 0 ;
11030 PyObject * obj1 = 0 ;
11031 char * kwnames[] = {
11032 (char *) "self",(char *) "other", NULL
11033 };
11034
11035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
11036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11037 if (!SWIG_IsOK(res1)) {
11038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D___eq__" "', expected argument " "1"" of type '" "wxRect2D *""'");
11039 }
11040 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11041 arg2 = obj1;
11042 {
11043 result = (bool)wxRect2D___eq__(arg1,arg2);
11044 if (PyErr_Occurred()) SWIG_fail;
11045 }
11046 {
11047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11048 }
11049 return resultobj;
11050 fail:
11051 return NULL;
11052 }
11053
11054
11055 SWIGINTERN PyObject *_wrap_Rect2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11056 PyObject *resultobj = 0;
11057 wxRect2D *arg1 = (wxRect2D *) 0 ;
11058 PyObject *arg2 = (PyObject *) 0 ;
11059 bool result;
11060 void *argp1 = 0 ;
11061 int res1 = 0 ;
11062 PyObject * obj0 = 0 ;
11063 PyObject * obj1 = 0 ;
11064 char * kwnames[] = {
11065 (char *) "self",(char *) "other", NULL
11066 };
11067
11068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
11069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11070 if (!SWIG_IsOK(res1)) {
11071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D___ne__" "', expected argument " "1"" of type '" "wxRect2D *""'");
11072 }
11073 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11074 arg2 = obj1;
11075 {
11076 result = (bool)wxRect2D___ne__(arg1,arg2);
11077 if (PyErr_Occurred()) SWIG_fail;
11078 }
11079 {
11080 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11081 }
11082 return resultobj;
11083 fail:
11084 return NULL;
11085 }
11086
11087
11088 SWIGINTERN PyObject *_wrap_Rect2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11089 PyObject *resultobj = 0;
11090 wxRect2D *arg1 = (wxRect2D *) 0 ;
11091 wxDouble arg2 ;
11092 void *argp1 = 0 ;
11093 int res1 = 0 ;
11094 void *argp2 ;
11095 int res2 = 0 ;
11096 PyObject *swig_obj[2] ;
11097
11098 if (!SWIG_Python_UnpackTuple(args,"Rect2D_x_set",2,2,swig_obj)) SWIG_fail;
11099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11100 if (!SWIG_IsOK(res1)) {
11101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_x_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11102 }
11103 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11104 {
11105 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11106 if (!SWIG_IsOK(res2)) {
11107 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_x_set" "', expected argument " "2"" of type '" "wxDouble""'");
11108 }
11109 if (!argp2) {
11110 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_x_set" "', expected argument " "2"" of type '" "wxDouble""'");
11111 } else {
11112 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11113 arg2 = *temp;
11114 if (SWIG_IsNewObj(res2)) delete temp;
11115 }
11116 }
11117 if (arg1) (arg1)->m_x = arg2;
11118
11119 resultobj = SWIG_Py_Void();
11120 return resultobj;
11121 fail:
11122 return NULL;
11123 }
11124
11125
11126 SWIGINTERN PyObject *_wrap_Rect2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11127 PyObject *resultobj = 0;
11128 wxRect2D *arg1 = (wxRect2D *) 0 ;
11129 wxDouble result;
11130 void *argp1 = 0 ;
11131 int res1 = 0 ;
11132 PyObject *swig_obj[1] ;
11133
11134 if (!args) SWIG_fail;
11135 swig_obj[0] = args;
11136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11137 if (!SWIG_IsOK(res1)) {
11138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_x_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11139 }
11140 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11141 result = ((arg1)->m_x);
11142 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11143 return resultobj;
11144 fail:
11145 return NULL;
11146 }
11147
11148
11149 SWIGINTERN PyObject *_wrap_Rect2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11150 PyObject *resultobj = 0;
11151 wxRect2D *arg1 = (wxRect2D *) 0 ;
11152 wxDouble arg2 ;
11153 void *argp1 = 0 ;
11154 int res1 = 0 ;
11155 void *argp2 ;
11156 int res2 = 0 ;
11157 PyObject *swig_obj[2] ;
11158
11159 if (!SWIG_Python_UnpackTuple(args,"Rect2D_y_set",2,2,swig_obj)) SWIG_fail;
11160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11161 if (!SWIG_IsOK(res1)) {
11162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_y_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11163 }
11164 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11165 {
11166 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11167 if (!SWIG_IsOK(res2)) {
11168 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_y_set" "', expected argument " "2"" of type '" "wxDouble""'");
11169 }
11170 if (!argp2) {
11171 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_y_set" "', expected argument " "2"" of type '" "wxDouble""'");
11172 } else {
11173 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11174 arg2 = *temp;
11175 if (SWIG_IsNewObj(res2)) delete temp;
11176 }
11177 }
11178 if (arg1) (arg1)->m_y = arg2;
11179
11180 resultobj = SWIG_Py_Void();
11181 return resultobj;
11182 fail:
11183 return NULL;
11184 }
11185
11186
11187 SWIGINTERN PyObject *_wrap_Rect2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11188 PyObject *resultobj = 0;
11189 wxRect2D *arg1 = (wxRect2D *) 0 ;
11190 wxDouble result;
11191 void *argp1 = 0 ;
11192 int res1 = 0 ;
11193 PyObject *swig_obj[1] ;
11194
11195 if (!args) SWIG_fail;
11196 swig_obj[0] = args;
11197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11198 if (!SWIG_IsOK(res1)) {
11199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_y_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11200 }
11201 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11202 result = ((arg1)->m_y);
11203 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11204 return resultobj;
11205 fail:
11206 return NULL;
11207 }
11208
11209
11210 SWIGINTERN PyObject *_wrap_Rect2D_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11211 PyObject *resultobj = 0;
11212 wxRect2D *arg1 = (wxRect2D *) 0 ;
11213 wxDouble arg2 ;
11214 void *argp1 = 0 ;
11215 int res1 = 0 ;
11216 void *argp2 ;
11217 int res2 = 0 ;
11218 PyObject *swig_obj[2] ;
11219
11220 if (!SWIG_Python_UnpackTuple(args,"Rect2D_width_set",2,2,swig_obj)) SWIG_fail;
11221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11222 if (!SWIG_IsOK(res1)) {
11223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_width_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11224 }
11225 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11226 {
11227 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11228 if (!SWIG_IsOK(res2)) {
11229 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_width_set" "', expected argument " "2"" of type '" "wxDouble""'");
11230 }
11231 if (!argp2) {
11232 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_width_set" "', expected argument " "2"" of type '" "wxDouble""'");
11233 } else {
11234 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11235 arg2 = *temp;
11236 if (SWIG_IsNewObj(res2)) delete temp;
11237 }
11238 }
11239 if (arg1) (arg1)->m_width = arg2;
11240
11241 resultobj = SWIG_Py_Void();
11242 return resultobj;
11243 fail:
11244 return NULL;
11245 }
11246
11247
11248 SWIGINTERN PyObject *_wrap_Rect2D_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11249 PyObject *resultobj = 0;
11250 wxRect2D *arg1 = (wxRect2D *) 0 ;
11251 wxDouble result;
11252 void *argp1 = 0 ;
11253 int res1 = 0 ;
11254 PyObject *swig_obj[1] ;
11255
11256 if (!args) SWIG_fail;
11257 swig_obj[0] = args;
11258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11259 if (!SWIG_IsOK(res1)) {
11260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_width_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11261 }
11262 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11263 result = ((arg1)->m_width);
11264 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11265 return resultobj;
11266 fail:
11267 return NULL;
11268 }
11269
11270
11271 SWIGINTERN PyObject *_wrap_Rect2D_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11272 PyObject *resultobj = 0;
11273 wxRect2D *arg1 = (wxRect2D *) 0 ;
11274 wxDouble arg2 ;
11275 void *argp1 = 0 ;
11276 int res1 = 0 ;
11277 void *argp2 ;
11278 int res2 = 0 ;
11279 PyObject *swig_obj[2] ;
11280
11281 if (!SWIG_Python_UnpackTuple(args,"Rect2D_height_set",2,2,swig_obj)) SWIG_fail;
11282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11283 if (!SWIG_IsOK(res1)) {
11284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_height_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11285 }
11286 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11287 {
11288 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11289 if (!SWIG_IsOK(res2)) {
11290 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_height_set" "', expected argument " "2"" of type '" "wxDouble""'");
11291 }
11292 if (!argp2) {
11293 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_height_set" "', expected argument " "2"" of type '" "wxDouble""'");
11294 } else {
11295 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11296 arg2 = *temp;
11297 if (SWIG_IsNewObj(res2)) delete temp;
11298 }
11299 }
11300 if (arg1) (arg1)->m_height = arg2;
11301
11302 resultobj = SWIG_Py_Void();
11303 return resultobj;
11304 fail:
11305 return NULL;
11306 }
11307
11308
11309 SWIGINTERN PyObject *_wrap_Rect2D_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11310 PyObject *resultobj = 0;
11311 wxRect2D *arg1 = (wxRect2D *) 0 ;
11312 wxDouble result;
11313 void *argp1 = 0 ;
11314 int res1 = 0 ;
11315 PyObject *swig_obj[1] ;
11316
11317 if (!args) SWIG_fail;
11318 swig_obj[0] = args;
11319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11320 if (!SWIG_IsOK(res1)) {
11321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_height_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11322 }
11323 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11324 result = ((arg1)->m_height);
11325 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11326 return resultobj;
11327 fail:
11328 return NULL;
11329 }
11330
11331
11332 SWIGINTERN PyObject *_wrap_Rect2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11333 PyObject *resultobj = 0;
11334 wxRect2D *arg1 = (wxRect2D *) 0 ;
11335 wxDouble arg2 = (wxDouble) 0 ;
11336 wxDouble arg3 = (wxDouble) 0 ;
11337 wxDouble arg4 = (wxDouble) 0 ;
11338 wxDouble arg5 = (wxDouble) 0 ;
11339 void *argp1 = 0 ;
11340 int res1 = 0 ;
11341 void *argp2 ;
11342 int res2 = 0 ;
11343 void *argp3 ;
11344 int res3 = 0 ;
11345 void *argp4 ;
11346 int res4 = 0 ;
11347 void *argp5 ;
11348 int res5 = 0 ;
11349 PyObject * obj0 = 0 ;
11350 PyObject * obj1 = 0 ;
11351 PyObject * obj2 = 0 ;
11352 PyObject * obj3 = 0 ;
11353 PyObject * obj4 = 0 ;
11354 char * kwnames[] = {
11355 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
11356 };
11357
11358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect2D_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
11359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11360 if (!SWIG_IsOK(res1)) {
11361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11362 }
11363 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11364 if (obj1) {
11365 {
11366 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11367 if (!SWIG_IsOK(res2)) {
11368 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Set" "', expected argument " "2"" of type '" "wxDouble""'");
11369 }
11370 if (!argp2) {
11371 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "2"" of type '" "wxDouble""'");
11372 } else {
11373 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11374 arg2 = *temp;
11375 if (SWIG_IsNewObj(res2)) delete temp;
11376 }
11377 }
11378 }
11379 if (obj2) {
11380 {
11381 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
11382 if (!SWIG_IsOK(res3)) {
11383 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Set" "', expected argument " "3"" of type '" "wxDouble""'");
11384 }
11385 if (!argp3) {
11386 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "3"" of type '" "wxDouble""'");
11387 } else {
11388 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
11389 arg3 = *temp;
11390 if (SWIG_IsNewObj(res3)) delete temp;
11391 }
11392 }
11393 }
11394 if (obj3) {
11395 {
11396 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
11397 if (!SWIG_IsOK(res4)) {
11398 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Rect2D_Set" "', expected argument " "4"" of type '" "wxDouble""'");
11399 }
11400 if (!argp4) {
11401 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "4"" of type '" "wxDouble""'");
11402 } else {
11403 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
11404 arg4 = *temp;
11405 if (SWIG_IsNewObj(res4)) delete temp;
11406 }
11407 }
11408 }
11409 if (obj4) {
11410 {
11411 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDouble, 0 | 0);
11412 if (!SWIG_IsOK(res5)) {
11413 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Rect2D_Set" "', expected argument " "5"" of type '" "wxDouble""'");
11414 }
11415 if (!argp5) {
11416 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "5"" of type '" "wxDouble""'");
11417 } else {
11418 wxDouble * temp = reinterpret_cast< wxDouble * >(argp5);
11419 arg5 = *temp;
11420 if (SWIG_IsNewObj(res5)) delete temp;
11421 }
11422 }
11423 }
11424 {
11425 wxRect2D_Set(arg1,arg2,arg3,arg4,arg5);
11426 if (PyErr_Occurred()) SWIG_fail;
11427 }
11428 resultobj = SWIG_Py_Void();
11429 return resultobj;
11430 fail:
11431 return NULL;
11432 }
11433
11434
11435 SWIGINTERN PyObject *_wrap_Rect2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11436 PyObject *resultobj = 0;
11437 wxRect2D *arg1 = (wxRect2D *) 0 ;
11438 PyObject *result = 0 ;
11439 void *argp1 = 0 ;
11440 int res1 = 0 ;
11441 PyObject *swig_obj[1] ;
11442
11443 if (!args) SWIG_fail;
11444 swig_obj[0] = args;
11445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11446 if (!SWIG_IsOK(res1)) {
11447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11448 }
11449 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11450 {
11451 result = (PyObject *)wxRect2D_Get(arg1);
11452 if (PyErr_Occurred()) SWIG_fail;
11453 }
11454 resultobj = result;
11455 return resultobj;
11456 fail:
11457 return NULL;
11458 }
11459
11460
11461 SWIGINTERN PyObject *Rect2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11462 PyObject *obj;
11463 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11464 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect2D, SWIG_NewClientData(obj));
11465 return SWIG_Py_Void();
11466 }
11467
11468 SWIGINTERN PyObject *Rect2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11469 return SWIG_Python_InitShadowInstance(args);
11470 }
11471
11472 SWIGINTERN int DefaultPosition_set(PyObject *) {
11473 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
11474 return 1;
11475 }
11476
11477
11478 SWIGINTERN PyObject *DefaultPosition_get(void) {
11479 PyObject *pyobj = 0;
11480
11481 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
11482 return pyobj;
11483 }
11484
11485
11486 SWIGINTERN int DefaultSize_set(PyObject *) {
11487 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
11488 return 1;
11489 }
11490
11491
11492 SWIGINTERN PyObject *DefaultSize_get(void) {
11493 PyObject *pyobj = 0;
11494
11495 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
11496 return pyobj;
11497 }
11498
11499
11500 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11501 PyObject *resultobj = 0;
11502 PyObject *arg1 = (PyObject *) 0 ;
11503 wxPyInputStream *result = 0 ;
11504 PyObject * obj0 = 0 ;
11505 char * kwnames[] = {
11506 (char *) "p", NULL
11507 };
11508
11509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
11510 arg1 = obj0;
11511 {
11512 PyThreadState* __tstate = wxPyBeginAllowThreads();
11513 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
11514 wxPyEndAllowThreads(__tstate);
11515 if (PyErr_Occurred()) SWIG_fail;
11516 }
11517 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
11518 return resultobj;
11519 fail:
11520 return NULL;
11521 }
11522
11523
11524 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11525 PyObject *resultobj = 0;
11526 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11527 void *argp1 = 0 ;
11528 int res1 = 0 ;
11529 PyObject *swig_obj[1] ;
11530
11531 if (!args) SWIG_fail;
11532 swig_obj[0] = args;
11533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
11534 if (!SWIG_IsOK(res1)) {
11535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11536 }
11537 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11538 {
11539 PyThreadState* __tstate = wxPyBeginAllowThreads();
11540 delete arg1;
11541
11542 wxPyEndAllowThreads(__tstate);
11543 if (PyErr_Occurred()) SWIG_fail;
11544 }
11545 resultobj = SWIG_Py_Void();
11546 return resultobj;
11547 fail:
11548 return NULL;
11549 }
11550
11551
11552 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11553 PyObject *resultobj = 0;
11554 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11555 void *argp1 = 0 ;
11556 int res1 = 0 ;
11557 PyObject *swig_obj[1] ;
11558
11559 if (!args) SWIG_fail;
11560 swig_obj[0] = args;
11561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11562 if (!SWIG_IsOK(res1)) {
11563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11564 }
11565 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11566 {
11567 PyThreadState* __tstate = wxPyBeginAllowThreads();
11568 (arg1)->close();
11569 wxPyEndAllowThreads(__tstate);
11570 if (PyErr_Occurred()) SWIG_fail;
11571 }
11572 resultobj = SWIG_Py_Void();
11573 return resultobj;
11574 fail:
11575 return NULL;
11576 }
11577
11578
11579 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11580 PyObject *resultobj = 0;
11581 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11582 void *argp1 = 0 ;
11583 int res1 = 0 ;
11584 PyObject *swig_obj[1] ;
11585
11586 if (!args) SWIG_fail;
11587 swig_obj[0] = args;
11588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11589 if (!SWIG_IsOK(res1)) {
11590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11591 }
11592 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11593 {
11594 PyThreadState* __tstate = wxPyBeginAllowThreads();
11595 (arg1)->flush();
11596 wxPyEndAllowThreads(__tstate);
11597 if (PyErr_Occurred()) SWIG_fail;
11598 }
11599 resultobj = SWIG_Py_Void();
11600 return resultobj;
11601 fail:
11602 return NULL;
11603 }
11604
11605
11606 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11607 PyObject *resultobj = 0;
11608 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11609 bool result;
11610 void *argp1 = 0 ;
11611 int res1 = 0 ;
11612 PyObject *swig_obj[1] ;
11613
11614 if (!args) SWIG_fail;
11615 swig_obj[0] = args;
11616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11617 if (!SWIG_IsOK(res1)) {
11618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11619 }
11620 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11621 {
11622 PyThreadState* __tstate = wxPyBeginAllowThreads();
11623 result = (bool)(arg1)->eof();
11624 wxPyEndAllowThreads(__tstate);
11625 if (PyErr_Occurred()) SWIG_fail;
11626 }
11627 {
11628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11629 }
11630 return resultobj;
11631 fail:
11632 return NULL;
11633 }
11634
11635
11636 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11637 PyObject *resultobj = 0;
11638 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11639 int arg2 = (int) -1 ;
11640 PyObject *result = 0 ;
11641 void *argp1 = 0 ;
11642 int res1 = 0 ;
11643 int val2 ;
11644 int ecode2 = 0 ;
11645 PyObject * obj0 = 0 ;
11646 PyObject * obj1 = 0 ;
11647 char * kwnames[] = {
11648 (char *) "self",(char *) "size", NULL
11649 };
11650
11651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
11652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11653 if (!SWIG_IsOK(res1)) {
11654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11655 }
11656 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11657 if (obj1) {
11658 ecode2 = SWIG_AsVal_int(obj1, &val2);
11659 if (!SWIG_IsOK(ecode2)) {
11660 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
11661 }
11662 arg2 = static_cast< int >(val2);
11663 }
11664 {
11665 PyThreadState* __tstate = wxPyBeginAllowThreads();
11666 result = (PyObject *)(arg1)->read(arg2);
11667 wxPyEndAllowThreads(__tstate);
11668 if (PyErr_Occurred()) SWIG_fail;
11669 }
11670 resultobj = result;
11671 return resultobj;
11672 fail:
11673 return NULL;
11674 }
11675
11676
11677 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11678 PyObject *resultobj = 0;
11679 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11680 int arg2 = (int) -1 ;
11681 PyObject *result = 0 ;
11682 void *argp1 = 0 ;
11683 int res1 = 0 ;
11684 int val2 ;
11685 int ecode2 = 0 ;
11686 PyObject * obj0 = 0 ;
11687 PyObject * obj1 = 0 ;
11688 char * kwnames[] = {
11689 (char *) "self",(char *) "size", NULL
11690 };
11691
11692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
11693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11694 if (!SWIG_IsOK(res1)) {
11695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11696 }
11697 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11698 if (obj1) {
11699 ecode2 = SWIG_AsVal_int(obj1, &val2);
11700 if (!SWIG_IsOK(ecode2)) {
11701 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
11702 }
11703 arg2 = static_cast< int >(val2);
11704 }
11705 {
11706 PyThreadState* __tstate = wxPyBeginAllowThreads();
11707 result = (PyObject *)(arg1)->readline(arg2);
11708 wxPyEndAllowThreads(__tstate);
11709 if (PyErr_Occurred()) SWIG_fail;
11710 }
11711 resultobj = result;
11712 return resultobj;
11713 fail:
11714 return NULL;
11715 }
11716
11717
11718 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11719 PyObject *resultobj = 0;
11720 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11721 int arg2 = (int) -1 ;
11722 PyObject *result = 0 ;
11723 void *argp1 = 0 ;
11724 int res1 = 0 ;
11725 int val2 ;
11726 int ecode2 = 0 ;
11727 PyObject * obj0 = 0 ;
11728 PyObject * obj1 = 0 ;
11729 char * kwnames[] = {
11730 (char *) "self",(char *) "sizehint", NULL
11731 };
11732
11733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
11734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11735 if (!SWIG_IsOK(res1)) {
11736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11737 }
11738 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11739 if (obj1) {
11740 ecode2 = SWIG_AsVal_int(obj1, &val2);
11741 if (!SWIG_IsOK(ecode2)) {
11742 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
11743 }
11744 arg2 = static_cast< int >(val2);
11745 }
11746 {
11747 PyThreadState* __tstate = wxPyBeginAllowThreads();
11748 result = (PyObject *)(arg1)->readlines(arg2);
11749 wxPyEndAllowThreads(__tstate);
11750 if (PyErr_Occurred()) SWIG_fail;
11751 }
11752 resultobj = result;
11753 return resultobj;
11754 fail:
11755 return NULL;
11756 }
11757
11758
11759 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11760 PyObject *resultobj = 0;
11761 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11762 int arg2 ;
11763 int arg3 = (int) 0 ;
11764 void *argp1 = 0 ;
11765 int res1 = 0 ;
11766 int val2 ;
11767 int ecode2 = 0 ;
11768 int val3 ;
11769 int ecode3 = 0 ;
11770 PyObject * obj0 = 0 ;
11771 PyObject * obj1 = 0 ;
11772 PyObject * obj2 = 0 ;
11773 char * kwnames[] = {
11774 (char *) "self",(char *) "offset",(char *) "whence", NULL
11775 };
11776
11777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11779 if (!SWIG_IsOK(res1)) {
11780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11781 }
11782 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11783 ecode2 = SWIG_AsVal_int(obj1, &val2);
11784 if (!SWIG_IsOK(ecode2)) {
11785 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
11786 }
11787 arg2 = static_cast< int >(val2);
11788 if (obj2) {
11789 ecode3 = SWIG_AsVal_int(obj2, &val3);
11790 if (!SWIG_IsOK(ecode3)) {
11791 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
11792 }
11793 arg3 = static_cast< int >(val3);
11794 }
11795 {
11796 PyThreadState* __tstate = wxPyBeginAllowThreads();
11797 (arg1)->seek(arg2,arg3);
11798 wxPyEndAllowThreads(__tstate);
11799 if (PyErr_Occurred()) SWIG_fail;
11800 }
11801 resultobj = SWIG_Py_Void();
11802 return resultobj;
11803 fail:
11804 return NULL;
11805 }
11806
11807
11808 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11809 PyObject *resultobj = 0;
11810 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11811 int result;
11812 void *argp1 = 0 ;
11813 int res1 = 0 ;
11814 PyObject *swig_obj[1] ;
11815
11816 if (!args) SWIG_fail;
11817 swig_obj[0] = args;
11818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11819 if (!SWIG_IsOK(res1)) {
11820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11821 }
11822 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11823 {
11824 PyThreadState* __tstate = wxPyBeginAllowThreads();
11825 result = (int)(arg1)->tell();
11826 wxPyEndAllowThreads(__tstate);
11827 if (PyErr_Occurred()) SWIG_fail;
11828 }
11829 resultobj = SWIG_From_int(static_cast< int >(result));
11830 return resultobj;
11831 fail:
11832 return NULL;
11833 }
11834
11835
11836 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11837 PyObject *resultobj = 0;
11838 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11839 char result;
11840 void *argp1 = 0 ;
11841 int res1 = 0 ;
11842 PyObject *swig_obj[1] ;
11843
11844 if (!args) SWIG_fail;
11845 swig_obj[0] = args;
11846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11847 if (!SWIG_IsOK(res1)) {
11848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11849 }
11850 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11851 {
11852 PyThreadState* __tstate = wxPyBeginAllowThreads();
11853 result = (char)(arg1)->Peek();
11854 wxPyEndAllowThreads(__tstate);
11855 if (PyErr_Occurred()) SWIG_fail;
11856 }
11857 resultobj = SWIG_From_char(static_cast< char >(result));
11858 return resultobj;
11859 fail:
11860 return NULL;
11861 }
11862
11863
11864 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11865 PyObject *resultobj = 0;
11866 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11867 char result;
11868 void *argp1 = 0 ;
11869 int res1 = 0 ;
11870 PyObject *swig_obj[1] ;
11871
11872 if (!args) SWIG_fail;
11873 swig_obj[0] = args;
11874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11875 if (!SWIG_IsOK(res1)) {
11876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11877 }
11878 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11879 {
11880 PyThreadState* __tstate = wxPyBeginAllowThreads();
11881 result = (char)(arg1)->GetC();
11882 wxPyEndAllowThreads(__tstate);
11883 if (PyErr_Occurred()) SWIG_fail;
11884 }
11885 resultobj = SWIG_From_char(static_cast< char >(result));
11886 return resultobj;
11887 fail:
11888 return NULL;
11889 }
11890
11891
11892 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11893 PyObject *resultobj = 0;
11894 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11895 size_t result;
11896 void *argp1 = 0 ;
11897 int res1 = 0 ;
11898 PyObject *swig_obj[1] ;
11899
11900 if (!args) SWIG_fail;
11901 swig_obj[0] = args;
11902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11903 if (!SWIG_IsOK(res1)) {
11904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11905 }
11906 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11907 {
11908 PyThreadState* __tstate = wxPyBeginAllowThreads();
11909 result = (size_t)(arg1)->LastRead();
11910 wxPyEndAllowThreads(__tstate);
11911 if (PyErr_Occurred()) SWIG_fail;
11912 }
11913 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
11914 return resultobj;
11915 fail:
11916 return NULL;
11917 }
11918
11919
11920 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11921 PyObject *resultobj = 0;
11922 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11923 bool result;
11924 void *argp1 = 0 ;
11925 int res1 = 0 ;
11926 PyObject *swig_obj[1] ;
11927
11928 if (!args) SWIG_fail;
11929 swig_obj[0] = args;
11930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11931 if (!SWIG_IsOK(res1)) {
11932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11933 }
11934 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11935 {
11936 PyThreadState* __tstate = wxPyBeginAllowThreads();
11937 result = (bool)(arg1)->CanRead();
11938 wxPyEndAllowThreads(__tstate);
11939 if (PyErr_Occurred()) SWIG_fail;
11940 }
11941 {
11942 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11943 }
11944 return resultobj;
11945 fail:
11946 return NULL;
11947 }
11948
11949
11950 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11951 PyObject *resultobj = 0;
11952 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11953 bool result;
11954 void *argp1 = 0 ;
11955 int res1 = 0 ;
11956 PyObject *swig_obj[1] ;
11957
11958 if (!args) SWIG_fail;
11959 swig_obj[0] = args;
11960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11961 if (!SWIG_IsOK(res1)) {
11962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11963 }
11964 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11965 {
11966 PyThreadState* __tstate = wxPyBeginAllowThreads();
11967 result = (bool)(arg1)->Eof();
11968 wxPyEndAllowThreads(__tstate);
11969 if (PyErr_Occurred()) SWIG_fail;
11970 }
11971 {
11972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11973 }
11974 return resultobj;
11975 fail:
11976 return NULL;
11977 }
11978
11979
11980 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11981 PyObject *resultobj = 0;
11982 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11983 char arg2 ;
11984 bool result;
11985 void *argp1 = 0 ;
11986 int res1 = 0 ;
11987 char val2 ;
11988 int ecode2 = 0 ;
11989 PyObject * obj0 = 0 ;
11990 PyObject * obj1 = 0 ;
11991 char * kwnames[] = {
11992 (char *) "self",(char *) "c", NULL
11993 };
11994
11995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
11996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11997 if (!SWIG_IsOK(res1)) {
11998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11999 }
12000 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12001 ecode2 = SWIG_AsVal_char(obj1, &val2);
12002 if (!SWIG_IsOK(ecode2)) {
12003 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
12004 }
12005 arg2 = static_cast< char >(val2);
12006 {
12007 PyThreadState* __tstate = wxPyBeginAllowThreads();
12008 result = (bool)(arg1)->Ungetch(arg2);
12009 wxPyEndAllowThreads(__tstate);
12010 if (PyErr_Occurred()) SWIG_fail;
12011 }
12012 {
12013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12014 }
12015 return resultobj;
12016 fail:
12017 return NULL;
12018 }
12019
12020
12021 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12022 PyObject *resultobj = 0;
12023 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12024 long arg2 ;
12025 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
12026 long result;
12027 void *argp1 = 0 ;
12028 int res1 = 0 ;
12029 long val2 ;
12030 int ecode2 = 0 ;
12031 int val3 ;
12032 int ecode3 = 0 ;
12033 PyObject * obj0 = 0 ;
12034 PyObject * obj1 = 0 ;
12035 PyObject * obj2 = 0 ;
12036 char * kwnames[] = {
12037 (char *) "self",(char *) "pos",(char *) "mode", NULL
12038 };
12039
12040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12042 if (!SWIG_IsOK(res1)) {
12043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12044 }
12045 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12046 ecode2 = SWIG_AsVal_long(obj1, &val2);
12047 if (!SWIG_IsOK(ecode2)) {
12048 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
12049 }
12050 arg2 = static_cast< long >(val2);
12051 if (obj2) {
12052 ecode3 = SWIG_AsVal_int(obj2, &val3);
12053 if (!SWIG_IsOK(ecode3)) {
12054 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
12055 }
12056 arg3 = static_cast< wxSeekMode >(val3);
12057 }
12058 {
12059 PyThreadState* __tstate = wxPyBeginAllowThreads();
12060 result = (long)(arg1)->SeekI(arg2,arg3);
12061 wxPyEndAllowThreads(__tstate);
12062 if (PyErr_Occurred()) SWIG_fail;
12063 }
12064 resultobj = SWIG_From_long(static_cast< long >(result));
12065 return resultobj;
12066 fail:
12067 return NULL;
12068 }
12069
12070
12071 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12072 PyObject *resultobj = 0;
12073 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12074 long result;
12075 void *argp1 = 0 ;
12076 int res1 = 0 ;
12077 PyObject *swig_obj[1] ;
12078
12079 if (!args) SWIG_fail;
12080 swig_obj[0] = args;
12081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12082 if (!SWIG_IsOK(res1)) {
12083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12084 }
12085 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12086 {
12087 PyThreadState* __tstate = wxPyBeginAllowThreads();
12088 result = (long)(arg1)->TellI();
12089 wxPyEndAllowThreads(__tstate);
12090 if (PyErr_Occurred()) SWIG_fail;
12091 }
12092 resultobj = SWIG_From_long(static_cast< long >(result));
12093 return resultobj;
12094 fail:
12095 return NULL;
12096 }
12097
12098
12099 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12100 PyObject *obj;
12101 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12102 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
12103 return SWIG_Py_Void();
12104 }
12105
12106 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12107 return SWIG_Python_InitShadowInstance(args);
12108 }
12109
12110 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12111 PyObject *resultobj = 0;
12112 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
12113 PyObject *arg2 = (PyObject *) 0 ;
12114 void *argp1 = 0 ;
12115 int res1 = 0 ;
12116 PyObject * obj0 = 0 ;
12117 PyObject * obj1 = 0 ;
12118 char * kwnames[] = {
12119 (char *) "self",(char *) "obj", NULL
12120 };
12121
12122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
12123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
12124 if (!SWIG_IsOK(res1)) {
12125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
12126 }
12127 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
12128 arg2 = obj1;
12129 {
12130 PyThreadState* __tstate = wxPyBeginAllowThreads();
12131 wxOutputStream_write(arg1,arg2);
12132 wxPyEndAllowThreads(__tstate);
12133 if (PyErr_Occurred()) SWIG_fail;
12134 }
12135 resultobj = SWIG_Py_Void();
12136 return resultobj;
12137 fail:
12138 return NULL;
12139 }
12140
12141
12142 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12143 PyObject *resultobj = 0;
12144 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
12145 size_t result;
12146 void *argp1 = 0 ;
12147 int res1 = 0 ;
12148 PyObject *swig_obj[1] ;
12149
12150 if (!args) SWIG_fail;
12151 swig_obj[0] = args;
12152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
12153 if (!SWIG_IsOK(res1)) {
12154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
12155 }
12156 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
12157 {
12158 PyThreadState* __tstate = wxPyBeginAllowThreads();
12159 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
12160 wxPyEndAllowThreads(__tstate);
12161 if (PyErr_Occurred()) SWIG_fail;
12162 }
12163 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
12164 return resultobj;
12165 fail:
12166 return NULL;
12167 }
12168
12169
12170 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12171 PyObject *obj;
12172 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12173 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
12174 return SWIG_Py_Void();
12175 }
12176
12177 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12178 PyObject *resultobj = 0;
12179 wxInputStream *arg1 = (wxInputStream *) 0 ;
12180 wxString *arg2 = 0 ;
12181 wxString *arg3 = 0 ;
12182 wxString *arg4 = 0 ;
12183 wxDateTime arg5 ;
12184 wxFSFile *result = 0 ;
12185 wxPyInputStream *temp1 ;
12186 bool temp2 = false ;
12187 bool temp3 = false ;
12188 bool temp4 = false ;
12189 void *argp5 ;
12190 int res5 = 0 ;
12191 PyObject * obj0 = 0 ;
12192 PyObject * obj1 = 0 ;
12193 PyObject * obj2 = 0 ;
12194 PyObject * obj3 = 0 ;
12195 PyObject * obj4 = 0 ;
12196 char * kwnames[] = {
12197 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
12198 };
12199
12200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
12201 {
12202 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12203 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
12204 } else {
12205 PyErr_Clear(); // clear the failure of the wxPyConvert above
12206 arg1 = wxPyCBInputStream_create(obj0, true);
12207 if (arg1 == NULL) {
12208 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12209 SWIG_fail;
12210 }
12211 }
12212 }
12213 {
12214 arg2 = wxString_in_helper(obj1);
12215 if (arg2 == NULL) SWIG_fail;
12216 temp2 = true;
12217 }
12218 {
12219 arg3 = wxString_in_helper(obj2);
12220 if (arg3 == NULL) SWIG_fail;
12221 temp3 = true;
12222 }
12223 {
12224 arg4 = wxString_in_helper(obj3);
12225 if (arg4 == NULL) SWIG_fail;
12226 temp4 = true;
12227 }
12228 {
12229 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
12230 if (!SWIG_IsOK(res5)) {
12231 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
12232 }
12233 if (!argp5) {
12234 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
12235 } else {
12236 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
12237 arg5 = *temp;
12238 if (SWIG_IsNewObj(res5)) delete temp;
12239 }
12240 }
12241 {
12242 PyThreadState* __tstate = wxPyBeginAllowThreads();
12243 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
12244 wxPyEndAllowThreads(__tstate);
12245 if (PyErr_Occurred()) SWIG_fail;
12246 }
12247 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
12248 {
12249 if (temp2)
12250 delete arg2;
12251 }
12252 {
12253 if (temp3)
12254 delete arg3;
12255 }
12256 {
12257 if (temp4)
12258 delete arg4;
12259 }
12260 return resultobj;
12261 fail:
12262 {
12263 if (temp2)
12264 delete arg2;
12265 }
12266 {
12267 if (temp3)
12268 delete arg3;
12269 }
12270 {
12271 if (temp4)
12272 delete arg4;
12273 }
12274 return NULL;
12275 }
12276
12277
12278 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12279 PyObject *resultobj = 0;
12280 wxFSFile *arg1 = (wxFSFile *) 0 ;
12281 void *argp1 = 0 ;
12282 int res1 = 0 ;
12283 PyObject *swig_obj[1] ;
12284
12285 if (!args) SWIG_fail;
12286 swig_obj[0] = args;
12287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
12288 if (!SWIG_IsOK(res1)) {
12289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
12290 }
12291 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12292 {
12293 PyThreadState* __tstate = wxPyBeginAllowThreads();
12294 delete arg1;
12295
12296 wxPyEndAllowThreads(__tstate);
12297 if (PyErr_Occurred()) SWIG_fail;
12298 }
12299 resultobj = SWIG_Py_Void();
12300 return resultobj;
12301 fail:
12302 return NULL;
12303 }
12304
12305
12306 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12307 PyObject *resultobj = 0;
12308 wxFSFile *arg1 = (wxFSFile *) 0 ;
12309 wxInputStream *result = 0 ;
12310 void *argp1 = 0 ;
12311 int res1 = 0 ;
12312 PyObject *swig_obj[1] ;
12313
12314 if (!args) SWIG_fail;
12315 swig_obj[0] = args;
12316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12317 if (!SWIG_IsOK(res1)) {
12318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
12319 }
12320 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12321 {
12322 PyThreadState* __tstate = wxPyBeginAllowThreads();
12323 result = (wxInputStream *)(arg1)->GetStream();
12324 wxPyEndAllowThreads(__tstate);
12325 if (PyErr_Occurred()) SWIG_fail;
12326 }
12327 {
12328 wxPyInputStream * _ptr = NULL;
12329
12330 if (result) {
12331 _ptr = new wxPyInputStream(result);
12332 }
12333 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
12334 }
12335 return resultobj;
12336 fail:
12337 return NULL;
12338 }
12339
12340
12341 SWIGINTERN PyObject *_wrap_FSFile_DetachStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12342 PyObject *resultobj = 0;
12343 wxFSFile *arg1 = (wxFSFile *) 0 ;
12344 void *argp1 = 0 ;
12345 int res1 = 0 ;
12346 PyObject *swig_obj[1] ;
12347
12348 if (!args) SWIG_fail;
12349 swig_obj[0] = args;
12350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12351 if (!SWIG_IsOK(res1)) {
12352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_DetachStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
12353 }
12354 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12355 {
12356 PyThreadState* __tstate = wxPyBeginAllowThreads();
12357 (arg1)->DetachStream();
12358 wxPyEndAllowThreads(__tstate);
12359 if (PyErr_Occurred()) SWIG_fail;
12360 }
12361 resultobj = SWIG_Py_Void();
12362 return resultobj;
12363 fail:
12364 return NULL;
12365 }
12366
12367
12368 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12369 PyObject *resultobj = 0;
12370 wxFSFile *arg1 = (wxFSFile *) 0 ;
12371 wxString *result = 0 ;
12372 void *argp1 = 0 ;
12373 int res1 = 0 ;
12374 PyObject *swig_obj[1] ;
12375
12376 if (!args) SWIG_fail;
12377 swig_obj[0] = args;
12378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12379 if (!SWIG_IsOK(res1)) {
12380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
12381 }
12382 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12383 {
12384 PyThreadState* __tstate = wxPyBeginAllowThreads();
12385 {
12386 wxString const &_result_ref = (arg1)->GetMimeType();
12387 result = (wxString *) &_result_ref;
12388 }
12389 wxPyEndAllowThreads(__tstate);
12390 if (PyErr_Occurred()) SWIG_fail;
12391 }
12392 {
12393 #if wxUSE_UNICODE
12394 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12395 #else
12396 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12397 #endif
12398 }
12399 return resultobj;
12400 fail:
12401 return NULL;
12402 }
12403
12404
12405 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12406 PyObject *resultobj = 0;
12407 wxFSFile *arg1 = (wxFSFile *) 0 ;
12408 wxString *result = 0 ;
12409 void *argp1 = 0 ;
12410 int res1 = 0 ;
12411 PyObject *swig_obj[1] ;
12412
12413 if (!args) SWIG_fail;
12414 swig_obj[0] = args;
12415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12416 if (!SWIG_IsOK(res1)) {
12417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
12418 }
12419 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12420 {
12421 PyThreadState* __tstate = wxPyBeginAllowThreads();
12422 {
12423 wxString const &_result_ref = (arg1)->GetLocation();
12424 result = (wxString *) &_result_ref;
12425 }
12426 wxPyEndAllowThreads(__tstate);
12427 if (PyErr_Occurred()) SWIG_fail;
12428 }
12429 {
12430 #if wxUSE_UNICODE
12431 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12432 #else
12433 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12434 #endif
12435 }
12436 return resultobj;
12437 fail:
12438 return NULL;
12439 }
12440
12441
12442 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12443 PyObject *resultobj = 0;
12444 wxFSFile *arg1 = (wxFSFile *) 0 ;
12445 wxString *result = 0 ;
12446 void *argp1 = 0 ;
12447 int res1 = 0 ;
12448 PyObject *swig_obj[1] ;
12449
12450 if (!args) SWIG_fail;
12451 swig_obj[0] = args;
12452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12453 if (!SWIG_IsOK(res1)) {
12454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
12455 }
12456 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12457 {
12458 PyThreadState* __tstate = wxPyBeginAllowThreads();
12459 {
12460 wxString const &_result_ref = (arg1)->GetAnchor();
12461 result = (wxString *) &_result_ref;
12462 }
12463 wxPyEndAllowThreads(__tstate);
12464 if (PyErr_Occurred()) SWIG_fail;
12465 }
12466 {
12467 #if wxUSE_UNICODE
12468 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12469 #else
12470 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12471 #endif
12472 }
12473 return resultobj;
12474 fail:
12475 return NULL;
12476 }
12477
12478
12479 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12480 PyObject *resultobj = 0;
12481 wxFSFile *arg1 = (wxFSFile *) 0 ;
12482 wxDateTime result;
12483 void *argp1 = 0 ;
12484 int res1 = 0 ;
12485 PyObject *swig_obj[1] ;
12486
12487 if (!args) SWIG_fail;
12488 swig_obj[0] = args;
12489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12490 if (!SWIG_IsOK(res1)) {
12491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
12492 }
12493 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12494 {
12495 PyThreadState* __tstate = wxPyBeginAllowThreads();
12496 result = (arg1)->GetModificationTime();
12497 wxPyEndAllowThreads(__tstate);
12498 if (PyErr_Occurred()) SWIG_fail;
12499 }
12500 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
12501 return resultobj;
12502 fail:
12503 return NULL;
12504 }
12505
12506
12507 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12508 PyObject *obj;
12509 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12510 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
12511 return SWIG_Py_Void();
12512 }
12513
12514 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12515 return SWIG_Python_InitShadowInstance(args);
12516 }
12517
12518 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12519 PyObject *resultobj = 0;
12520 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
12521 void *argp1 = 0 ;
12522 int res1 = 0 ;
12523 PyObject *swig_obj[1] ;
12524
12525 if (!args) SWIG_fail;
12526 swig_obj[0] = args;
12527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
12528 if (!SWIG_IsOK(res1)) {
12529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
12530 }
12531 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
12532 {
12533 PyThreadState* __tstate = wxPyBeginAllowThreads();
12534 delete arg1;
12535
12536 wxPyEndAllowThreads(__tstate);
12537 if (PyErr_Occurred()) SWIG_fail;
12538 }
12539 resultobj = SWIG_Py_Void();
12540 return resultobj;
12541 fail:
12542 return NULL;
12543 }
12544
12545
12546 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12547 PyObject *obj;
12548 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12549 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
12550 return SWIG_Py_Void();
12551 }
12552
12553 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12554 PyObject *resultobj = 0;
12555 wxPyFileSystemHandler *result = 0 ;
12556
12557 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
12558 {
12559 PyThreadState* __tstate = wxPyBeginAllowThreads();
12560 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
12561 wxPyEndAllowThreads(__tstate);
12562 if (PyErr_Occurred()) SWIG_fail;
12563 }
12564 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
12565 return resultobj;
12566 fail:
12567 return NULL;
12568 }
12569
12570
12571 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12572 PyObject *resultobj = 0;
12573 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12574 PyObject *arg2 = (PyObject *) 0 ;
12575 PyObject *arg3 = (PyObject *) 0 ;
12576 void *argp1 = 0 ;
12577 int res1 = 0 ;
12578 PyObject * obj0 = 0 ;
12579 PyObject * obj1 = 0 ;
12580 PyObject * obj2 = 0 ;
12581 char * kwnames[] = {
12582 (char *) "self",(char *) "self",(char *) "_class", NULL
12583 };
12584
12585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12587 if (!SWIG_IsOK(res1)) {
12588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12589 }
12590 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12591 arg2 = obj1;
12592 arg3 = obj2;
12593 {
12594 PyThreadState* __tstate = wxPyBeginAllowThreads();
12595 (arg1)->_setCallbackInfo(arg2,arg3);
12596 wxPyEndAllowThreads(__tstate);
12597 if (PyErr_Occurred()) SWIG_fail;
12598 }
12599 resultobj = SWIG_Py_Void();
12600 return resultobj;
12601 fail:
12602 return NULL;
12603 }
12604
12605
12606 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12607 PyObject *resultobj = 0;
12608 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12609 wxString *arg2 = 0 ;
12610 bool result;
12611 void *argp1 = 0 ;
12612 int res1 = 0 ;
12613 bool temp2 = false ;
12614 PyObject * obj0 = 0 ;
12615 PyObject * obj1 = 0 ;
12616 char * kwnames[] = {
12617 (char *) "self",(char *) "location", NULL
12618 };
12619
12620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
12621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12622 if (!SWIG_IsOK(res1)) {
12623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12624 }
12625 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12626 {
12627 arg2 = wxString_in_helper(obj1);
12628 if (arg2 == NULL) SWIG_fail;
12629 temp2 = true;
12630 }
12631 {
12632 PyThreadState* __tstate = wxPyBeginAllowThreads();
12633 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
12634 wxPyEndAllowThreads(__tstate);
12635 if (PyErr_Occurred()) SWIG_fail;
12636 }
12637 {
12638 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12639 }
12640 {
12641 if (temp2)
12642 delete arg2;
12643 }
12644 return resultobj;
12645 fail:
12646 {
12647 if (temp2)
12648 delete arg2;
12649 }
12650 return NULL;
12651 }
12652
12653
12654 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12655 PyObject *resultobj = 0;
12656 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12657 wxFileSystem *arg2 = 0 ;
12658 wxString *arg3 = 0 ;
12659 wxFSFile *result = 0 ;
12660 void *argp1 = 0 ;
12661 int res1 = 0 ;
12662 void *argp2 = 0 ;
12663 int res2 = 0 ;
12664 bool temp3 = false ;
12665 PyObject * obj0 = 0 ;
12666 PyObject * obj1 = 0 ;
12667 PyObject * obj2 = 0 ;
12668 char * kwnames[] = {
12669 (char *) "self",(char *) "fs",(char *) "location", NULL
12670 };
12671
12672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12674 if (!SWIG_IsOK(res1)) {
12675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12676 }
12677 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12678 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
12679 if (!SWIG_IsOK(res2)) {
12680 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
12681 }
12682 if (!argp2) {
12683 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
12684 }
12685 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
12686 {
12687 arg3 = wxString_in_helper(obj2);
12688 if (arg3 == NULL) SWIG_fail;
12689 temp3 = true;
12690 }
12691 {
12692 PyThreadState* __tstate = wxPyBeginAllowThreads();
12693 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
12694 wxPyEndAllowThreads(__tstate);
12695 if (PyErr_Occurred()) SWIG_fail;
12696 }
12697 {
12698 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
12699 }
12700 {
12701 if (temp3)
12702 delete arg3;
12703 }
12704 return resultobj;
12705 fail:
12706 {
12707 if (temp3)
12708 delete arg3;
12709 }
12710 return NULL;
12711 }
12712
12713
12714 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12715 PyObject *resultobj = 0;
12716 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12717 wxString *arg2 = 0 ;
12718 int arg3 = (int) 0 ;
12719 wxString result;
12720 void *argp1 = 0 ;
12721 int res1 = 0 ;
12722 bool temp2 = false ;
12723 int val3 ;
12724 int ecode3 = 0 ;
12725 PyObject * obj0 = 0 ;
12726 PyObject * obj1 = 0 ;
12727 PyObject * obj2 = 0 ;
12728 char * kwnames[] = {
12729 (char *) "self",(char *) "spec",(char *) "flags", NULL
12730 };
12731
12732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12734 if (!SWIG_IsOK(res1)) {
12735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12736 }
12737 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12738 {
12739 arg2 = wxString_in_helper(obj1);
12740 if (arg2 == NULL) SWIG_fail;
12741 temp2 = true;
12742 }
12743 if (obj2) {
12744 ecode3 = SWIG_AsVal_int(obj2, &val3);
12745 if (!SWIG_IsOK(ecode3)) {
12746 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
12747 }
12748 arg3 = static_cast< int >(val3);
12749 }
12750 {
12751 PyThreadState* __tstate = wxPyBeginAllowThreads();
12752 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
12753 wxPyEndAllowThreads(__tstate);
12754 if (PyErr_Occurred()) SWIG_fail;
12755 }
12756 {
12757 #if wxUSE_UNICODE
12758 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12759 #else
12760 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12761 #endif
12762 }
12763 {
12764 if (temp2)
12765 delete arg2;
12766 }
12767 return resultobj;
12768 fail:
12769 {
12770 if (temp2)
12771 delete arg2;
12772 }
12773 return NULL;
12774 }
12775
12776
12777 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12778 PyObject *resultobj = 0;
12779 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12780 wxString result;
12781 void *argp1 = 0 ;
12782 int res1 = 0 ;
12783 PyObject *swig_obj[1] ;
12784
12785 if (!args) SWIG_fail;
12786 swig_obj[0] = args;
12787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12788 if (!SWIG_IsOK(res1)) {
12789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12790 }
12791 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12792 {
12793 PyThreadState* __tstate = wxPyBeginAllowThreads();
12794 result = (arg1)->FindNext();
12795 wxPyEndAllowThreads(__tstate);
12796 if (PyErr_Occurred()) SWIG_fail;
12797 }
12798 {
12799 #if wxUSE_UNICODE
12800 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12801 #else
12802 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12803 #endif
12804 }
12805 return resultobj;
12806 fail:
12807 return NULL;
12808 }
12809
12810
12811 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12812 PyObject *resultobj = 0;
12813 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12814 wxString *arg2 = 0 ;
12815 wxString result;
12816 void *argp1 = 0 ;
12817 int res1 = 0 ;
12818 bool temp2 = false ;
12819 PyObject * obj0 = 0 ;
12820 PyObject * obj1 = 0 ;
12821 char * kwnames[] = {
12822 (char *) "self",(char *) "location", NULL
12823 };
12824
12825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
12826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12827 if (!SWIG_IsOK(res1)) {
12828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12829 }
12830 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12831 {
12832 arg2 = wxString_in_helper(obj1);
12833 if (arg2 == NULL) SWIG_fail;
12834 temp2 = true;
12835 }
12836 {
12837 PyThreadState* __tstate = wxPyBeginAllowThreads();
12838 result = (arg1)->GetProtocol((wxString const &)*arg2);
12839 wxPyEndAllowThreads(__tstate);
12840 if (PyErr_Occurred()) SWIG_fail;
12841 }
12842 {
12843 #if wxUSE_UNICODE
12844 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12845 #else
12846 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12847 #endif
12848 }
12849 {
12850 if (temp2)
12851 delete arg2;
12852 }
12853 return resultobj;
12854 fail:
12855 {
12856 if (temp2)
12857 delete arg2;
12858 }
12859 return NULL;
12860 }
12861
12862
12863 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12864 PyObject *resultobj = 0;
12865 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12866 wxString *arg2 = 0 ;
12867 wxString result;
12868 void *argp1 = 0 ;
12869 int res1 = 0 ;
12870 bool temp2 = false ;
12871 PyObject * obj0 = 0 ;
12872 PyObject * obj1 = 0 ;
12873 char * kwnames[] = {
12874 (char *) "self",(char *) "location", NULL
12875 };
12876
12877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
12878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12879 if (!SWIG_IsOK(res1)) {
12880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12881 }
12882 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12883 {
12884 arg2 = wxString_in_helper(obj1);
12885 if (arg2 == NULL) SWIG_fail;
12886 temp2 = true;
12887 }
12888 {
12889 PyThreadState* __tstate = wxPyBeginAllowThreads();
12890 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
12891 wxPyEndAllowThreads(__tstate);
12892 if (PyErr_Occurred()) SWIG_fail;
12893 }
12894 {
12895 #if wxUSE_UNICODE
12896 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12897 #else
12898 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12899 #endif
12900 }
12901 {
12902 if (temp2)
12903 delete arg2;
12904 }
12905 return resultobj;
12906 fail:
12907 {
12908 if (temp2)
12909 delete arg2;
12910 }
12911 return NULL;
12912 }
12913
12914
12915 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12916 PyObject *resultobj = 0;
12917 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12918 wxString *arg2 = 0 ;
12919 wxString result;
12920 void *argp1 = 0 ;
12921 int res1 = 0 ;
12922 bool temp2 = false ;
12923 PyObject * obj0 = 0 ;
12924 PyObject * obj1 = 0 ;
12925 char * kwnames[] = {
12926 (char *) "self",(char *) "location", NULL
12927 };
12928
12929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
12930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12931 if (!SWIG_IsOK(res1)) {
12932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12933 }
12934 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12935 {
12936 arg2 = wxString_in_helper(obj1);
12937 if (arg2 == NULL) SWIG_fail;
12938 temp2 = true;
12939 }
12940 {
12941 PyThreadState* __tstate = wxPyBeginAllowThreads();
12942 result = (arg1)->GetAnchor((wxString const &)*arg2);
12943 wxPyEndAllowThreads(__tstate);
12944 if (PyErr_Occurred()) SWIG_fail;
12945 }
12946 {
12947 #if wxUSE_UNICODE
12948 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12949 #else
12950 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12951 #endif
12952 }
12953 {
12954 if (temp2)
12955 delete arg2;
12956 }
12957 return resultobj;
12958 fail:
12959 {
12960 if (temp2)
12961 delete arg2;
12962 }
12963 return NULL;
12964 }
12965
12966
12967 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12968 PyObject *resultobj = 0;
12969 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12970 wxString *arg2 = 0 ;
12971 wxString result;
12972 void *argp1 = 0 ;
12973 int res1 = 0 ;
12974 bool temp2 = false ;
12975 PyObject * obj0 = 0 ;
12976 PyObject * obj1 = 0 ;
12977 char * kwnames[] = {
12978 (char *) "self",(char *) "location", NULL
12979 };
12980
12981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
12982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12983 if (!SWIG_IsOK(res1)) {
12984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12985 }
12986 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12987 {
12988 arg2 = wxString_in_helper(obj1);
12989 if (arg2 == NULL) SWIG_fail;
12990 temp2 = true;
12991 }
12992 {
12993 PyThreadState* __tstate = wxPyBeginAllowThreads();
12994 result = (arg1)->GetRightLocation((wxString const &)*arg2);
12995 wxPyEndAllowThreads(__tstate);
12996 if (PyErr_Occurred()) SWIG_fail;
12997 }
12998 {
12999 #if wxUSE_UNICODE
13000 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13001 #else
13002 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13003 #endif
13004 }
13005 {
13006 if (temp2)
13007 delete arg2;
13008 }
13009 return resultobj;
13010 fail:
13011 {
13012 if (temp2)
13013 delete arg2;
13014 }
13015 return NULL;
13016 }
13017
13018
13019 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13020 PyObject *resultobj = 0;
13021 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
13022 wxString *arg2 = 0 ;
13023 wxString result;
13024 void *argp1 = 0 ;
13025 int res1 = 0 ;
13026 bool temp2 = false ;
13027 PyObject * obj0 = 0 ;
13028 PyObject * obj1 = 0 ;
13029 char * kwnames[] = {
13030 (char *) "self",(char *) "location", NULL
13031 };
13032
13033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
13034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
13035 if (!SWIG_IsOK(res1)) {
13036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
13037 }
13038 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
13039 {
13040 arg2 = wxString_in_helper(obj1);
13041 if (arg2 == NULL) SWIG_fail;
13042 temp2 = true;
13043 }
13044 {
13045 PyThreadState* __tstate = wxPyBeginAllowThreads();
13046 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
13047 wxPyEndAllowThreads(__tstate);
13048 if (PyErr_Occurred()) SWIG_fail;
13049 }
13050 {
13051 #if wxUSE_UNICODE
13052 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13053 #else
13054 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13055 #endif
13056 }
13057 {
13058 if (temp2)
13059 delete arg2;
13060 }
13061 return resultobj;
13062 fail:
13063 {
13064 if (temp2)
13065 delete arg2;
13066 }
13067 return NULL;
13068 }
13069
13070
13071 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13072 PyObject *obj;
13073 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13074 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
13075 return SWIG_Py_Void();
13076 }
13077
13078 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13079 return SWIG_Python_InitShadowInstance(args);
13080 }
13081
13082 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13083 PyObject *resultobj = 0;
13084 wxFileSystem *result = 0 ;
13085
13086 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
13087 {
13088 PyThreadState* __tstate = wxPyBeginAllowThreads();
13089 result = (wxFileSystem *)new wxFileSystem();
13090 wxPyEndAllowThreads(__tstate);
13091 if (PyErr_Occurred()) SWIG_fail;
13092 }
13093 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystem, SWIG_POINTER_NEW | 0 );
13094 return resultobj;
13095 fail:
13096 return NULL;
13097 }
13098
13099
13100 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13101 PyObject *resultobj = 0;
13102 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13103 void *argp1 = 0 ;
13104 int res1 = 0 ;
13105 PyObject *swig_obj[1] ;
13106
13107 if (!args) SWIG_fail;
13108 swig_obj[0] = args;
13109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
13110 if (!SWIG_IsOK(res1)) {
13111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13112 }
13113 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13114 {
13115 PyThreadState* __tstate = wxPyBeginAllowThreads();
13116 delete arg1;
13117
13118 wxPyEndAllowThreads(__tstate);
13119 if (PyErr_Occurred()) SWIG_fail;
13120 }
13121 resultobj = SWIG_Py_Void();
13122 return resultobj;
13123 fail:
13124 return NULL;
13125 }
13126
13127
13128 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13129 PyObject *resultobj = 0;
13130 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13131 wxString *arg2 = 0 ;
13132 bool arg3 = (bool) false ;
13133 void *argp1 = 0 ;
13134 int res1 = 0 ;
13135 bool temp2 = false ;
13136 bool val3 ;
13137 int ecode3 = 0 ;
13138 PyObject * obj0 = 0 ;
13139 PyObject * obj1 = 0 ;
13140 PyObject * obj2 = 0 ;
13141 char * kwnames[] = {
13142 (char *) "self",(char *) "location",(char *) "is_dir", NULL
13143 };
13144
13145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13147 if (!SWIG_IsOK(res1)) {
13148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13149 }
13150 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13151 {
13152 arg2 = wxString_in_helper(obj1);
13153 if (arg2 == NULL) SWIG_fail;
13154 temp2 = true;
13155 }
13156 if (obj2) {
13157 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13158 if (!SWIG_IsOK(ecode3)) {
13159 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
13160 }
13161 arg3 = static_cast< bool >(val3);
13162 }
13163 {
13164 PyThreadState* __tstate = wxPyBeginAllowThreads();
13165 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
13166 wxPyEndAllowThreads(__tstate);
13167 if (PyErr_Occurred()) SWIG_fail;
13168 }
13169 resultobj = SWIG_Py_Void();
13170 {
13171 if (temp2)
13172 delete arg2;
13173 }
13174 return resultobj;
13175 fail:
13176 {
13177 if (temp2)
13178 delete arg2;
13179 }
13180 return NULL;
13181 }
13182
13183
13184 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13185 PyObject *resultobj = 0;
13186 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13187 wxString result;
13188 void *argp1 = 0 ;
13189 int res1 = 0 ;
13190 PyObject *swig_obj[1] ;
13191
13192 if (!args) SWIG_fail;
13193 swig_obj[0] = args;
13194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13195 if (!SWIG_IsOK(res1)) {
13196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13197 }
13198 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13199 {
13200 PyThreadState* __tstate = wxPyBeginAllowThreads();
13201 result = (arg1)->GetPath();
13202 wxPyEndAllowThreads(__tstate);
13203 if (PyErr_Occurred()) SWIG_fail;
13204 }
13205 {
13206 #if wxUSE_UNICODE
13207 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13208 #else
13209 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13210 #endif
13211 }
13212 return resultobj;
13213 fail:
13214 return NULL;
13215 }
13216
13217
13218 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13219 PyObject *resultobj = 0;
13220 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13221 wxString *arg2 = 0 ;
13222 wxFSFile *result = 0 ;
13223 void *argp1 = 0 ;
13224 int res1 = 0 ;
13225 bool temp2 = false ;
13226 PyObject * obj0 = 0 ;
13227 PyObject * obj1 = 0 ;
13228 char * kwnames[] = {
13229 (char *) "self",(char *) "location", NULL
13230 };
13231
13232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
13233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13234 if (!SWIG_IsOK(res1)) {
13235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13236 }
13237 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13238 {
13239 arg2 = wxString_in_helper(obj1);
13240 if (arg2 == NULL) SWIG_fail;
13241 temp2 = true;
13242 }
13243 {
13244 PyThreadState* __tstate = wxPyBeginAllowThreads();
13245 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
13246 wxPyEndAllowThreads(__tstate);
13247 if (PyErr_Occurred()) SWIG_fail;
13248 }
13249 {
13250 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13251 }
13252 {
13253 if (temp2)
13254 delete arg2;
13255 }
13256 return resultobj;
13257 fail:
13258 {
13259 if (temp2)
13260 delete arg2;
13261 }
13262 return NULL;
13263 }
13264
13265
13266 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13267 PyObject *resultobj = 0;
13268 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13269 wxString *arg2 = 0 ;
13270 int arg3 = (int) 0 ;
13271 wxString result;
13272 void *argp1 = 0 ;
13273 int res1 = 0 ;
13274 bool temp2 = false ;
13275 int val3 ;
13276 int ecode3 = 0 ;
13277 PyObject * obj0 = 0 ;
13278 PyObject * obj1 = 0 ;
13279 PyObject * obj2 = 0 ;
13280 char * kwnames[] = {
13281 (char *) "self",(char *) "spec",(char *) "flags", NULL
13282 };
13283
13284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13285 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13286 if (!SWIG_IsOK(res1)) {
13287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13288 }
13289 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13290 {
13291 arg2 = wxString_in_helper(obj1);
13292 if (arg2 == NULL) SWIG_fail;
13293 temp2 = true;
13294 }
13295 if (obj2) {
13296 ecode3 = SWIG_AsVal_int(obj2, &val3);
13297 if (!SWIG_IsOK(ecode3)) {
13298 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
13299 }
13300 arg3 = static_cast< int >(val3);
13301 }
13302 {
13303 PyThreadState* __tstate = wxPyBeginAllowThreads();
13304 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
13305 wxPyEndAllowThreads(__tstate);
13306 if (PyErr_Occurred()) SWIG_fail;
13307 }
13308 {
13309 #if wxUSE_UNICODE
13310 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13311 #else
13312 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13313 #endif
13314 }
13315 {
13316 if (temp2)
13317 delete arg2;
13318 }
13319 return resultobj;
13320 fail:
13321 {
13322 if (temp2)
13323 delete arg2;
13324 }
13325 return NULL;
13326 }
13327
13328
13329 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13330 PyObject *resultobj = 0;
13331 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13332 wxString result;
13333 void *argp1 = 0 ;
13334 int res1 = 0 ;
13335 PyObject *swig_obj[1] ;
13336
13337 if (!args) SWIG_fail;
13338 swig_obj[0] = args;
13339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13340 if (!SWIG_IsOK(res1)) {
13341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13342 }
13343 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13344 {
13345 PyThreadState* __tstate = wxPyBeginAllowThreads();
13346 result = (arg1)->FindNext();
13347 wxPyEndAllowThreads(__tstate);
13348 if (PyErr_Occurred()) SWIG_fail;
13349 }
13350 {
13351 #if wxUSE_UNICODE
13352 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13353 #else
13354 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13355 #endif
13356 }
13357 return resultobj;
13358 fail:
13359 return NULL;
13360 }
13361
13362
13363 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13364 PyObject *resultobj = 0;
13365 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
13366 int res1 = 0 ;
13367 PyObject * obj0 = 0 ;
13368 char * kwnames[] = {
13369 (char *) "handler", NULL
13370 };
13371
13372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
13373 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
13374 if (!SWIG_IsOK(res1)) {
13375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
13376 }
13377 {
13378 PyThreadState* __tstate = wxPyBeginAllowThreads();
13379 wxFileSystem::AddHandler(arg1);
13380 wxPyEndAllowThreads(__tstate);
13381 if (PyErr_Occurred()) SWIG_fail;
13382 }
13383 resultobj = SWIG_Py_Void();
13384 return resultobj;
13385 fail:
13386 return NULL;
13387 }
13388
13389
13390 SWIGINTERN PyObject *_wrap_FileSystem_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13391 PyObject *resultobj = 0;
13392 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
13393 wxFileSystemHandler *result = 0 ;
13394 void *argp1 = 0 ;
13395 int res1 = 0 ;
13396 PyObject * obj0 = 0 ;
13397 char * kwnames[] = {
13398 (char *) "handler", NULL
13399 };
13400
13401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_RemoveHandler",kwnames,&obj0)) SWIG_fail;
13402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystemHandler, 0 | 0 );
13403 if (!SWIG_IsOK(res1)) {
13404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_RemoveHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
13405 }
13406 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
13407 {
13408 PyThreadState* __tstate = wxPyBeginAllowThreads();
13409 result = (wxFileSystemHandler *)wxFileSystem::RemoveHandler(arg1);
13410 wxPyEndAllowThreads(__tstate);
13411 if (PyErr_Occurred()) SWIG_fail;
13412 }
13413 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_OWN | 0 );
13414 return resultobj;
13415 fail:
13416 return NULL;
13417 }
13418
13419
13420 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13421 PyObject *resultobj = 0;
13422
13423 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
13424 {
13425 PyThreadState* __tstate = wxPyBeginAllowThreads();
13426 wxFileSystem::CleanUpHandlers();
13427 wxPyEndAllowThreads(__tstate);
13428 if (PyErr_Occurred()) SWIG_fail;
13429 }
13430 resultobj = SWIG_Py_Void();
13431 return resultobj;
13432 fail:
13433 return NULL;
13434 }
13435
13436
13437 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13438 PyObject *resultobj = 0;
13439 wxString *arg1 = 0 ;
13440 wxString result;
13441 bool temp1 = false ;
13442 PyObject * obj0 = 0 ;
13443 char * kwnames[] = {
13444 (char *) "filename", NULL
13445 };
13446
13447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
13448 {
13449 arg1 = wxString_in_helper(obj0);
13450 if (arg1 == NULL) SWIG_fail;
13451 temp1 = true;
13452 }
13453 {
13454 PyThreadState* __tstate = wxPyBeginAllowThreads();
13455 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
13456 wxPyEndAllowThreads(__tstate);
13457 if (PyErr_Occurred()) SWIG_fail;
13458 }
13459 {
13460 #if wxUSE_UNICODE
13461 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13462 #else
13463 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13464 #endif
13465 }
13466 {
13467 if (temp1)
13468 delete arg1;
13469 }
13470 return resultobj;
13471 fail:
13472 {
13473 if (temp1)
13474 delete arg1;
13475 }
13476 return NULL;
13477 }
13478
13479
13480 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13481 PyObject *resultobj = 0;
13482 wxString *arg1 = 0 ;
13483 wxString result;
13484 bool temp1 = false ;
13485 PyObject * obj0 = 0 ;
13486 char * kwnames[] = {
13487 (char *) "url", NULL
13488 };
13489
13490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
13491 {
13492 arg1 = wxString_in_helper(obj0);
13493 if (arg1 == NULL) SWIG_fail;
13494 temp1 = true;
13495 }
13496 {
13497 PyThreadState* __tstate = wxPyBeginAllowThreads();
13498 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
13499 wxPyEndAllowThreads(__tstate);
13500 if (PyErr_Occurred()) SWIG_fail;
13501 }
13502 {
13503 #if wxUSE_UNICODE
13504 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13505 #else
13506 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13507 #endif
13508 }
13509 {
13510 if (temp1)
13511 delete arg1;
13512 }
13513 return resultobj;
13514 fail:
13515 {
13516 if (temp1)
13517 delete arg1;
13518 }
13519 return NULL;
13520 }
13521
13522
13523 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13524 PyObject *obj;
13525 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13526 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
13527 return SWIG_Py_Void();
13528 }
13529
13530 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13531 return SWIG_Python_InitShadowInstance(args);
13532 }
13533
13534 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13535 PyObject *resultobj = 0;
13536 wxInternetFSHandler *result = 0 ;
13537
13538 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
13539 {
13540 PyThreadState* __tstate = wxPyBeginAllowThreads();
13541 result = (wxInternetFSHandler *)new wxInternetFSHandler();
13542 wxPyEndAllowThreads(__tstate);
13543 if (PyErr_Occurred()) SWIG_fail;
13544 }
13545 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
13546 return resultobj;
13547 fail:
13548 return NULL;
13549 }
13550
13551
13552 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13553 PyObject *resultobj = 0;
13554 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
13555 wxString *arg2 = 0 ;
13556 bool result;
13557 void *argp1 = 0 ;
13558 int res1 = 0 ;
13559 bool temp2 = false ;
13560 PyObject * obj0 = 0 ;
13561 PyObject * obj1 = 0 ;
13562 char * kwnames[] = {
13563 (char *) "self",(char *) "location", NULL
13564 };
13565
13566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
13567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
13568 if (!SWIG_IsOK(res1)) {
13569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
13570 }
13571 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
13572 {
13573 arg2 = wxString_in_helper(obj1);
13574 if (arg2 == NULL) SWIG_fail;
13575 temp2 = true;
13576 }
13577 {
13578 PyThreadState* __tstate = wxPyBeginAllowThreads();
13579 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
13580 wxPyEndAllowThreads(__tstate);
13581 if (PyErr_Occurred()) SWIG_fail;
13582 }
13583 {
13584 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13585 }
13586 {
13587 if (temp2)
13588 delete arg2;
13589 }
13590 return resultobj;
13591 fail:
13592 {
13593 if (temp2)
13594 delete arg2;
13595 }
13596 return NULL;
13597 }
13598
13599
13600 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13601 PyObject *resultobj = 0;
13602 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
13603 wxFileSystem *arg2 = 0 ;
13604 wxString *arg3 = 0 ;
13605 wxFSFile *result = 0 ;
13606 void *argp1 = 0 ;
13607 int res1 = 0 ;
13608 void *argp2 = 0 ;
13609 int res2 = 0 ;
13610 bool temp3 = false ;
13611 PyObject * obj0 = 0 ;
13612 PyObject * obj1 = 0 ;
13613 PyObject * obj2 = 0 ;
13614 char * kwnames[] = {
13615 (char *) "self",(char *) "fs",(char *) "location", NULL
13616 };
13617
13618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13619 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
13620 if (!SWIG_IsOK(res1)) {
13621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
13622 }
13623 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
13624 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
13625 if (!SWIG_IsOK(res2)) {
13626 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13627 }
13628 if (!argp2) {
13629 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13630 }
13631 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
13632 {
13633 arg3 = wxString_in_helper(obj2);
13634 if (arg3 == NULL) SWIG_fail;
13635 temp3 = true;
13636 }
13637 {
13638 PyThreadState* __tstate = wxPyBeginAllowThreads();
13639 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
13640 wxPyEndAllowThreads(__tstate);
13641 if (PyErr_Occurred()) SWIG_fail;
13642 }
13643 {
13644 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13645 }
13646 {
13647 if (temp3)
13648 delete arg3;
13649 }
13650 return resultobj;
13651 fail:
13652 {
13653 if (temp3)
13654 delete arg3;
13655 }
13656 return NULL;
13657 }
13658
13659
13660 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13661 PyObject *obj;
13662 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13663 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
13664 return SWIG_Py_Void();
13665 }
13666
13667 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13668 return SWIG_Python_InitShadowInstance(args);
13669 }
13670
13671 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13672 PyObject *resultobj = 0;
13673 wxZipFSHandler *result = 0 ;
13674
13675 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
13676 {
13677 PyThreadState* __tstate = wxPyBeginAllowThreads();
13678 result = (wxZipFSHandler *)new wxZipFSHandler();
13679 wxPyEndAllowThreads(__tstate);
13680 if (PyErr_Occurred()) SWIG_fail;
13681 }
13682 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
13683 return resultobj;
13684 fail:
13685 return NULL;
13686 }
13687
13688
13689 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13690 PyObject *resultobj = 0;
13691 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13692 wxString *arg2 = 0 ;
13693 bool result;
13694 void *argp1 = 0 ;
13695 int res1 = 0 ;
13696 bool temp2 = false ;
13697 PyObject * obj0 = 0 ;
13698 PyObject * obj1 = 0 ;
13699 char * kwnames[] = {
13700 (char *) "self",(char *) "location", NULL
13701 };
13702
13703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
13704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13705 if (!SWIG_IsOK(res1)) {
13706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13707 }
13708 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13709 {
13710 arg2 = wxString_in_helper(obj1);
13711 if (arg2 == NULL) SWIG_fail;
13712 temp2 = true;
13713 }
13714 {
13715 PyThreadState* __tstate = wxPyBeginAllowThreads();
13716 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
13717 wxPyEndAllowThreads(__tstate);
13718 if (PyErr_Occurred()) SWIG_fail;
13719 }
13720 {
13721 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13722 }
13723 {
13724 if (temp2)
13725 delete arg2;
13726 }
13727 return resultobj;
13728 fail:
13729 {
13730 if (temp2)
13731 delete arg2;
13732 }
13733 return NULL;
13734 }
13735
13736
13737 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13738 PyObject *resultobj = 0;
13739 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13740 wxFileSystem *arg2 = 0 ;
13741 wxString *arg3 = 0 ;
13742 wxFSFile *result = 0 ;
13743 void *argp1 = 0 ;
13744 int res1 = 0 ;
13745 void *argp2 = 0 ;
13746 int res2 = 0 ;
13747 bool temp3 = false ;
13748 PyObject * obj0 = 0 ;
13749 PyObject * obj1 = 0 ;
13750 PyObject * obj2 = 0 ;
13751 char * kwnames[] = {
13752 (char *) "self",(char *) "fs",(char *) "location", NULL
13753 };
13754
13755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13757 if (!SWIG_IsOK(res1)) {
13758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13759 }
13760 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13761 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
13762 if (!SWIG_IsOK(res2)) {
13763 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13764 }
13765 if (!argp2) {
13766 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13767 }
13768 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
13769 {
13770 arg3 = wxString_in_helper(obj2);
13771 if (arg3 == NULL) SWIG_fail;
13772 temp3 = true;
13773 }
13774 {
13775 PyThreadState* __tstate = wxPyBeginAllowThreads();
13776 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
13777 wxPyEndAllowThreads(__tstate);
13778 if (PyErr_Occurred()) SWIG_fail;
13779 }
13780 {
13781 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13782 }
13783 {
13784 if (temp3)
13785 delete arg3;
13786 }
13787 return resultobj;
13788 fail:
13789 {
13790 if (temp3)
13791 delete arg3;
13792 }
13793 return NULL;
13794 }
13795
13796
13797 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13798 PyObject *resultobj = 0;
13799 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13800 wxString *arg2 = 0 ;
13801 int arg3 = (int) 0 ;
13802 wxString result;
13803 void *argp1 = 0 ;
13804 int res1 = 0 ;
13805 bool temp2 = false ;
13806 int val3 ;
13807 int ecode3 = 0 ;
13808 PyObject * obj0 = 0 ;
13809 PyObject * obj1 = 0 ;
13810 PyObject * obj2 = 0 ;
13811 char * kwnames[] = {
13812 (char *) "self",(char *) "spec",(char *) "flags", NULL
13813 };
13814
13815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13817 if (!SWIG_IsOK(res1)) {
13818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13819 }
13820 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13821 {
13822 arg2 = wxString_in_helper(obj1);
13823 if (arg2 == NULL) SWIG_fail;
13824 temp2 = true;
13825 }
13826 if (obj2) {
13827 ecode3 = SWIG_AsVal_int(obj2, &val3);
13828 if (!SWIG_IsOK(ecode3)) {
13829 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
13830 }
13831 arg3 = static_cast< int >(val3);
13832 }
13833 {
13834 PyThreadState* __tstate = wxPyBeginAllowThreads();
13835 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
13836 wxPyEndAllowThreads(__tstate);
13837 if (PyErr_Occurred()) SWIG_fail;
13838 }
13839 {
13840 #if wxUSE_UNICODE
13841 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13842 #else
13843 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13844 #endif
13845 }
13846 {
13847 if (temp2)
13848 delete arg2;
13849 }
13850 return resultobj;
13851 fail:
13852 {
13853 if (temp2)
13854 delete arg2;
13855 }
13856 return NULL;
13857 }
13858
13859
13860 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13861 PyObject *resultobj = 0;
13862 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13863 wxString result;
13864 void *argp1 = 0 ;
13865 int res1 = 0 ;
13866 PyObject *swig_obj[1] ;
13867
13868 if (!args) SWIG_fail;
13869 swig_obj[0] = args;
13870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13871 if (!SWIG_IsOK(res1)) {
13872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13873 }
13874 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13875 {
13876 PyThreadState* __tstate = wxPyBeginAllowThreads();
13877 result = (arg1)->FindNext();
13878 wxPyEndAllowThreads(__tstate);
13879 if (PyErr_Occurred()) SWIG_fail;
13880 }
13881 {
13882 #if wxUSE_UNICODE
13883 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13884 #else
13885 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13886 #endif
13887 }
13888 return resultobj;
13889 fail:
13890 return NULL;
13891 }
13892
13893
13894 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13895 PyObject *obj;
13896 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13897 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
13898 return SWIG_Py_Void();
13899 }
13900
13901 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13902 return SWIG_Python_InitShadowInstance(args);
13903 }
13904
13905 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13906 PyObject *resultobj = 0;
13907 wxString *arg1 = 0 ;
13908 wxImage *arg2 = 0 ;
13909 long arg3 ;
13910 bool temp1 = false ;
13911 void *argp2 = 0 ;
13912 int res2 = 0 ;
13913 long val3 ;
13914 int ecode3 = 0 ;
13915 PyObject * obj0 = 0 ;
13916 PyObject * obj1 = 0 ;
13917 PyObject * obj2 = 0 ;
13918 char * kwnames[] = {
13919 (char *) "filename",(char *) "image",(char *) "type", NULL
13920 };
13921
13922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13923 {
13924 arg1 = wxString_in_helper(obj0);
13925 if (arg1 == NULL) SWIG_fail;
13926 temp1 = true;
13927 }
13928 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
13929 if (!SWIG_IsOK(res2)) {
13930 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
13931 }
13932 if (!argp2) {
13933 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
13934 }
13935 arg2 = reinterpret_cast< wxImage * >(argp2);
13936 ecode3 = SWIG_AsVal_long(obj2, &val3);
13937 if (!SWIG_IsOK(ecode3)) {
13938 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
13939 }
13940 arg3 = static_cast< long >(val3);
13941 {
13942 PyThreadState* __tstate = wxPyBeginAllowThreads();
13943 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
13944 wxPyEndAllowThreads(__tstate);
13945 if (PyErr_Occurred()) SWIG_fail;
13946 }
13947 resultobj = SWIG_Py_Void();
13948 {
13949 if (temp1)
13950 delete arg1;
13951 }
13952 return resultobj;
13953 fail:
13954 {
13955 if (temp1)
13956 delete arg1;
13957 }
13958 return NULL;
13959 }
13960
13961
13962 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13963 PyObject *resultobj = 0;
13964 wxString *arg1 = 0 ;
13965 wxBitmap *arg2 = 0 ;
13966 long arg3 ;
13967 bool temp1 = false ;
13968 void *argp2 = 0 ;
13969 int res2 = 0 ;
13970 long val3 ;
13971 int ecode3 = 0 ;
13972 PyObject * obj0 = 0 ;
13973 PyObject * obj1 = 0 ;
13974 PyObject * obj2 = 0 ;
13975 char * kwnames[] = {
13976 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
13977 };
13978
13979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13980 {
13981 arg1 = wxString_in_helper(obj0);
13982 if (arg1 == NULL) SWIG_fail;
13983 temp1 = true;
13984 }
13985 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
13986 if (!SWIG_IsOK(res2)) {
13987 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
13988 }
13989 if (!argp2) {
13990 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
13991 }
13992 arg2 = reinterpret_cast< wxBitmap * >(argp2);
13993 ecode3 = SWIG_AsVal_long(obj2, &val3);
13994 if (!SWIG_IsOK(ecode3)) {
13995 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
13996 }
13997 arg3 = static_cast< long >(val3);
13998 {
13999 PyThreadState* __tstate = wxPyBeginAllowThreads();
14000 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
14001 wxPyEndAllowThreads(__tstate);
14002 if (PyErr_Occurred()) SWIG_fail;
14003 }
14004 resultobj = SWIG_Py_Void();
14005 {
14006 if (temp1)
14007 delete arg1;
14008 }
14009 return resultobj;
14010 fail:
14011 {
14012 if (temp1)
14013 delete arg1;
14014 }
14015 return NULL;
14016 }
14017
14018
14019 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14020 PyObject *resultobj = 0;
14021 wxString *arg1 = 0 ;
14022 PyObject *arg2 = (PyObject *) 0 ;
14023 bool temp1 = false ;
14024 PyObject * obj0 = 0 ;
14025 PyObject * obj1 = 0 ;
14026 char * kwnames[] = {
14027 (char *) "filename",(char *) "data", NULL
14028 };
14029
14030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
14031 {
14032 arg1 = wxString_in_helper(obj0);
14033 if (arg1 == NULL) SWIG_fail;
14034 temp1 = true;
14035 }
14036 arg2 = obj1;
14037 {
14038 PyThreadState* __tstate = wxPyBeginAllowThreads();
14039 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
14040 wxPyEndAllowThreads(__tstate);
14041 if (PyErr_Occurred()) SWIG_fail;
14042 }
14043 resultobj = SWIG_Py_Void();
14044 {
14045 if (temp1)
14046 delete arg1;
14047 }
14048 return resultobj;
14049 fail:
14050 {
14051 if (temp1)
14052 delete arg1;
14053 }
14054 return NULL;
14055 }
14056
14057
14058 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14059 PyObject *resultobj = 0;
14060 wxMemoryFSHandler *result = 0 ;
14061
14062 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
14063 {
14064 PyThreadState* __tstate = wxPyBeginAllowThreads();
14065 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
14066 wxPyEndAllowThreads(__tstate);
14067 if (PyErr_Occurred()) SWIG_fail;
14068 }
14069 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
14070 return resultobj;
14071 fail:
14072 return NULL;
14073 }
14074
14075
14076 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14077 PyObject *resultobj = 0;
14078 wxString *arg1 = 0 ;
14079 bool temp1 = false ;
14080 PyObject * obj0 = 0 ;
14081 char * kwnames[] = {
14082 (char *) "filename", NULL
14083 };
14084
14085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
14086 {
14087 arg1 = wxString_in_helper(obj0);
14088 if (arg1 == NULL) SWIG_fail;
14089 temp1 = true;
14090 }
14091 {
14092 PyThreadState* __tstate = wxPyBeginAllowThreads();
14093 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
14094 wxPyEndAllowThreads(__tstate);
14095 if (PyErr_Occurred()) SWIG_fail;
14096 }
14097 resultobj = SWIG_Py_Void();
14098 {
14099 if (temp1)
14100 delete arg1;
14101 }
14102 return resultobj;
14103 fail:
14104 {
14105 if (temp1)
14106 delete arg1;
14107 }
14108 return NULL;
14109 }
14110
14111
14112 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14113 PyObject *resultobj = 0;
14114 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14115 wxString *arg2 = 0 ;
14116 bool result;
14117 void *argp1 = 0 ;
14118 int res1 = 0 ;
14119 bool temp2 = false ;
14120 PyObject * obj0 = 0 ;
14121 PyObject * obj1 = 0 ;
14122 char * kwnames[] = {
14123 (char *) "self",(char *) "location", NULL
14124 };
14125
14126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
14127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14128 if (!SWIG_IsOK(res1)) {
14129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14130 }
14131 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14132 {
14133 arg2 = wxString_in_helper(obj1);
14134 if (arg2 == NULL) SWIG_fail;
14135 temp2 = true;
14136 }
14137 {
14138 PyThreadState* __tstate = wxPyBeginAllowThreads();
14139 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
14140 wxPyEndAllowThreads(__tstate);
14141 if (PyErr_Occurred()) SWIG_fail;
14142 }
14143 {
14144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14145 }
14146 {
14147 if (temp2)
14148 delete arg2;
14149 }
14150 return resultobj;
14151 fail:
14152 {
14153 if (temp2)
14154 delete arg2;
14155 }
14156 return NULL;
14157 }
14158
14159
14160 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14161 PyObject *resultobj = 0;
14162 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14163 wxFileSystem *arg2 = 0 ;
14164 wxString *arg3 = 0 ;
14165 wxFSFile *result = 0 ;
14166 void *argp1 = 0 ;
14167 int res1 = 0 ;
14168 void *argp2 = 0 ;
14169 int res2 = 0 ;
14170 bool temp3 = false ;
14171 PyObject * obj0 = 0 ;
14172 PyObject * obj1 = 0 ;
14173 PyObject * obj2 = 0 ;
14174 char * kwnames[] = {
14175 (char *) "self",(char *) "fs",(char *) "location", NULL
14176 };
14177
14178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14180 if (!SWIG_IsOK(res1)) {
14181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14182 }
14183 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14184 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
14185 if (!SWIG_IsOK(res2)) {
14186 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14187 }
14188 if (!argp2) {
14189 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14190 }
14191 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
14192 {
14193 arg3 = wxString_in_helper(obj2);
14194 if (arg3 == NULL) SWIG_fail;
14195 temp3 = true;
14196 }
14197 {
14198 PyThreadState* __tstate = wxPyBeginAllowThreads();
14199 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
14200 wxPyEndAllowThreads(__tstate);
14201 if (PyErr_Occurred()) SWIG_fail;
14202 }
14203 {
14204 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
14205 }
14206 {
14207 if (temp3)
14208 delete arg3;
14209 }
14210 return resultobj;
14211 fail:
14212 {
14213 if (temp3)
14214 delete arg3;
14215 }
14216 return NULL;
14217 }
14218
14219
14220 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14221 PyObject *resultobj = 0;
14222 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14223 wxString *arg2 = 0 ;
14224 int arg3 = (int) 0 ;
14225 wxString result;
14226 void *argp1 = 0 ;
14227 int res1 = 0 ;
14228 bool temp2 = false ;
14229 int val3 ;
14230 int ecode3 = 0 ;
14231 PyObject * obj0 = 0 ;
14232 PyObject * obj1 = 0 ;
14233 PyObject * obj2 = 0 ;
14234 char * kwnames[] = {
14235 (char *) "self",(char *) "spec",(char *) "flags", NULL
14236 };
14237
14238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14240 if (!SWIG_IsOK(res1)) {
14241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14242 }
14243 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14244 {
14245 arg2 = wxString_in_helper(obj1);
14246 if (arg2 == NULL) SWIG_fail;
14247 temp2 = true;
14248 }
14249 if (obj2) {
14250 ecode3 = SWIG_AsVal_int(obj2, &val3);
14251 if (!SWIG_IsOK(ecode3)) {
14252 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
14253 }
14254 arg3 = static_cast< int >(val3);
14255 }
14256 {
14257 PyThreadState* __tstate = wxPyBeginAllowThreads();
14258 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
14259 wxPyEndAllowThreads(__tstate);
14260 if (PyErr_Occurred()) SWIG_fail;
14261 }
14262 {
14263 #if wxUSE_UNICODE
14264 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14265 #else
14266 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14267 #endif
14268 }
14269 {
14270 if (temp2)
14271 delete arg2;
14272 }
14273 return resultobj;
14274 fail:
14275 {
14276 if (temp2)
14277 delete arg2;
14278 }
14279 return NULL;
14280 }
14281
14282
14283 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14284 PyObject *resultobj = 0;
14285 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14286 wxString result;
14287 void *argp1 = 0 ;
14288 int res1 = 0 ;
14289 PyObject *swig_obj[1] ;
14290
14291 if (!args) SWIG_fail;
14292 swig_obj[0] = args;
14293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14294 if (!SWIG_IsOK(res1)) {
14295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14296 }
14297 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14298 {
14299 PyThreadState* __tstate = wxPyBeginAllowThreads();
14300 result = (arg1)->FindNext();
14301 wxPyEndAllowThreads(__tstate);
14302 if (PyErr_Occurred()) SWIG_fail;
14303 }
14304 {
14305 #if wxUSE_UNICODE
14306 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14307 #else
14308 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14309 #endif
14310 }
14311 return resultobj;
14312 fail:
14313 return NULL;
14314 }
14315
14316
14317 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14318 PyObject *obj;
14319 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14320 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
14321 return SWIG_Py_Void();
14322 }
14323
14324 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14325 return SWIG_Python_InitShadowInstance(args);
14326 }
14327
14328 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14329 PyObject *resultobj = 0;
14330 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14331 wxString result;
14332 void *argp1 = 0 ;
14333 int res1 = 0 ;
14334 PyObject *swig_obj[1] ;
14335
14336 if (!args) SWIG_fail;
14337 swig_obj[0] = args;
14338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14339 if (!SWIG_IsOK(res1)) {
14340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14341 }
14342 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14343 {
14344 PyThreadState* __tstate = wxPyBeginAllowThreads();
14345 result = (arg1)->GetName();
14346 wxPyEndAllowThreads(__tstate);
14347 if (PyErr_Occurred()) SWIG_fail;
14348 }
14349 {
14350 #if wxUSE_UNICODE
14351 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14352 #else
14353 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14354 #endif
14355 }
14356 return resultobj;
14357 fail:
14358 return NULL;
14359 }
14360
14361
14362 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14363 PyObject *resultobj = 0;
14364 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14365 wxString result;
14366 void *argp1 = 0 ;
14367 int res1 = 0 ;
14368 PyObject *swig_obj[1] ;
14369
14370 if (!args) SWIG_fail;
14371 swig_obj[0] = args;
14372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14373 if (!SWIG_IsOK(res1)) {
14374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14375 }
14376 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14377 {
14378 PyThreadState* __tstate = wxPyBeginAllowThreads();
14379 result = (arg1)->GetExtension();
14380 wxPyEndAllowThreads(__tstate);
14381 if (PyErr_Occurred()) SWIG_fail;
14382 }
14383 {
14384 #if wxUSE_UNICODE
14385 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14386 #else
14387 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14388 #endif
14389 }
14390 return resultobj;
14391 fail:
14392 return NULL;
14393 }
14394
14395
14396 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14397 PyObject *resultobj = 0;
14398 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14399 long result;
14400 void *argp1 = 0 ;
14401 int res1 = 0 ;
14402 PyObject *swig_obj[1] ;
14403
14404 if (!args) SWIG_fail;
14405 swig_obj[0] = args;
14406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14407 if (!SWIG_IsOK(res1)) {
14408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14409 }
14410 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14411 {
14412 PyThreadState* __tstate = wxPyBeginAllowThreads();
14413 result = (long)(arg1)->GetType();
14414 wxPyEndAllowThreads(__tstate);
14415 if (PyErr_Occurred()) SWIG_fail;
14416 }
14417 resultobj = SWIG_From_long(static_cast< long >(result));
14418 return resultobj;
14419 fail:
14420 return NULL;
14421 }
14422
14423
14424 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14425 PyObject *resultobj = 0;
14426 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14427 wxString result;
14428 void *argp1 = 0 ;
14429 int res1 = 0 ;
14430 PyObject *swig_obj[1] ;
14431
14432 if (!args) SWIG_fail;
14433 swig_obj[0] = args;
14434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14435 if (!SWIG_IsOK(res1)) {
14436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14437 }
14438 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14439 {
14440 PyThreadState* __tstate = wxPyBeginAllowThreads();
14441 result = (arg1)->GetMimeType();
14442 wxPyEndAllowThreads(__tstate);
14443 if (PyErr_Occurred()) SWIG_fail;
14444 }
14445 {
14446 #if wxUSE_UNICODE
14447 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14448 #else
14449 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14450 #endif
14451 }
14452 return resultobj;
14453 fail:
14454 return NULL;
14455 }
14456
14457
14458 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14459 PyObject *resultobj = 0;
14460 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14461 wxString *arg2 = 0 ;
14462 bool result;
14463 void *argp1 = 0 ;
14464 int res1 = 0 ;
14465 bool temp2 = false ;
14466 PyObject * obj0 = 0 ;
14467 PyObject * obj1 = 0 ;
14468 char * kwnames[] = {
14469 (char *) "self",(char *) "name", NULL
14470 };
14471
14472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
14473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14474 if (!SWIG_IsOK(res1)) {
14475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14476 }
14477 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14478 {
14479 arg2 = wxString_in_helper(obj1);
14480 if (arg2 == NULL) SWIG_fail;
14481 temp2 = true;
14482 }
14483 {
14484 PyThreadState* __tstate = wxPyBeginAllowThreads();
14485 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
14486 wxPyEndAllowThreads(__tstate);
14487 if (PyErr_Occurred()) SWIG_fail;
14488 }
14489 {
14490 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14491 }
14492 {
14493 if (temp2)
14494 delete arg2;
14495 }
14496 return resultobj;
14497 fail:
14498 {
14499 if (temp2)
14500 delete arg2;
14501 }
14502 return NULL;
14503 }
14504
14505
14506 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14507 PyObject *resultobj = 0;
14508 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14509 wxInputStream *arg2 = 0 ;
14510 bool result;
14511 void *argp1 = 0 ;
14512 int res1 = 0 ;
14513 wxPyInputStream *temp2 ;
14514 bool created2 ;
14515 PyObject * obj0 = 0 ;
14516 PyObject * obj1 = 0 ;
14517 char * kwnames[] = {
14518 (char *) "self",(char *) "stream", NULL
14519 };
14520
14521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
14522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14523 if (!SWIG_IsOK(res1)) {
14524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14525 }
14526 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14527 {
14528 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14529 arg2 = temp2->m_wxis;
14530 created2 = false;
14531 } else {
14532 PyErr_Clear(); // clear the failure of the wxPyConvert above
14533 arg2 = wxPyCBInputStream_create(obj1, false);
14534 if (arg2 == NULL) {
14535 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14536 SWIG_fail;
14537 }
14538 created2 = true;
14539 }
14540 }
14541 {
14542 PyThreadState* __tstate = wxPyBeginAllowThreads();
14543 result = (bool)(arg1)->CanRead(*arg2);
14544 wxPyEndAllowThreads(__tstate);
14545 if (PyErr_Occurred()) SWIG_fail;
14546 }
14547 {
14548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14549 }
14550 {
14551 if (created2) delete arg2;
14552 }
14553 return resultobj;
14554 fail:
14555 {
14556 if (created2) delete arg2;
14557 }
14558 return NULL;
14559 }
14560
14561
14562 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14563 PyObject *resultobj = 0;
14564 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14565 wxString *arg2 = 0 ;
14566 void *argp1 = 0 ;
14567 int res1 = 0 ;
14568 bool temp2 = false ;
14569 PyObject * obj0 = 0 ;
14570 PyObject * obj1 = 0 ;
14571 char * kwnames[] = {
14572 (char *) "self",(char *) "name", NULL
14573 };
14574
14575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
14576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14577 if (!SWIG_IsOK(res1)) {
14578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14579 }
14580 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14581 {
14582 arg2 = wxString_in_helper(obj1);
14583 if (arg2 == NULL) SWIG_fail;
14584 temp2 = true;
14585 }
14586 {
14587 PyThreadState* __tstate = wxPyBeginAllowThreads();
14588 (arg1)->SetName((wxString const &)*arg2);
14589 wxPyEndAllowThreads(__tstate);
14590 if (PyErr_Occurred()) SWIG_fail;
14591 }
14592 resultobj = SWIG_Py_Void();
14593 {
14594 if (temp2)
14595 delete arg2;
14596 }
14597 return resultobj;
14598 fail:
14599 {
14600 if (temp2)
14601 delete arg2;
14602 }
14603 return NULL;
14604 }
14605
14606
14607 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14608 PyObject *resultobj = 0;
14609 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14610 wxString *arg2 = 0 ;
14611 void *argp1 = 0 ;
14612 int res1 = 0 ;
14613 bool temp2 = false ;
14614 PyObject * obj0 = 0 ;
14615 PyObject * obj1 = 0 ;
14616 char * kwnames[] = {
14617 (char *) "self",(char *) "extension", NULL
14618 };
14619
14620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
14621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14622 if (!SWIG_IsOK(res1)) {
14623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14624 }
14625 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14626 {
14627 arg2 = wxString_in_helper(obj1);
14628 if (arg2 == NULL) SWIG_fail;
14629 temp2 = true;
14630 }
14631 {
14632 PyThreadState* __tstate = wxPyBeginAllowThreads();
14633 (arg1)->SetExtension((wxString const &)*arg2);
14634 wxPyEndAllowThreads(__tstate);
14635 if (PyErr_Occurred()) SWIG_fail;
14636 }
14637 resultobj = SWIG_Py_Void();
14638 {
14639 if (temp2)
14640 delete arg2;
14641 }
14642 return resultobj;
14643 fail:
14644 {
14645 if (temp2)
14646 delete arg2;
14647 }
14648 return NULL;
14649 }
14650
14651
14652 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14653 PyObject *resultobj = 0;
14654 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14655 long arg2 ;
14656 void *argp1 = 0 ;
14657 int res1 = 0 ;
14658 long val2 ;
14659 int ecode2 = 0 ;
14660 PyObject * obj0 = 0 ;
14661 PyObject * obj1 = 0 ;
14662 char * kwnames[] = {
14663 (char *) "self",(char *) "type", NULL
14664 };
14665
14666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
14667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14668 if (!SWIG_IsOK(res1)) {
14669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14670 }
14671 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14672 ecode2 = SWIG_AsVal_long(obj1, &val2);
14673 if (!SWIG_IsOK(ecode2)) {
14674 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
14675 }
14676 arg2 = static_cast< long >(val2);
14677 {
14678 PyThreadState* __tstate = wxPyBeginAllowThreads();
14679 (arg1)->SetType(arg2);
14680 wxPyEndAllowThreads(__tstate);
14681 if (PyErr_Occurred()) SWIG_fail;
14682 }
14683 resultobj = SWIG_Py_Void();
14684 return resultobj;
14685 fail:
14686 return NULL;
14687 }
14688
14689
14690 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14691 PyObject *resultobj = 0;
14692 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14693 wxString *arg2 = 0 ;
14694 void *argp1 = 0 ;
14695 int res1 = 0 ;
14696 bool temp2 = false ;
14697 PyObject * obj0 = 0 ;
14698 PyObject * obj1 = 0 ;
14699 char * kwnames[] = {
14700 (char *) "self",(char *) "mimetype", NULL
14701 };
14702
14703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
14704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14705 if (!SWIG_IsOK(res1)) {
14706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14707 }
14708 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14709 {
14710 arg2 = wxString_in_helper(obj1);
14711 if (arg2 == NULL) SWIG_fail;
14712 temp2 = true;
14713 }
14714 {
14715 PyThreadState* __tstate = wxPyBeginAllowThreads();
14716 (arg1)->SetMimeType((wxString const &)*arg2);
14717 wxPyEndAllowThreads(__tstate);
14718 if (PyErr_Occurred()) SWIG_fail;
14719 }
14720 resultobj = SWIG_Py_Void();
14721 {
14722 if (temp2)
14723 delete arg2;
14724 }
14725 return resultobj;
14726 fail:
14727 {
14728 if (temp2)
14729 delete arg2;
14730 }
14731 return NULL;
14732 }
14733
14734
14735 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14736 PyObject *obj;
14737 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14738 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
14739 return SWIG_Py_Void();
14740 }
14741
14742 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14743 PyObject *resultobj = 0;
14744 wxPyImageHandler *result = 0 ;
14745
14746 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
14747 {
14748 PyThreadState* __tstate = wxPyBeginAllowThreads();
14749 result = (wxPyImageHandler *)new wxPyImageHandler();
14750 wxPyEndAllowThreads(__tstate);
14751 if (PyErr_Occurred()) SWIG_fail;
14752 }
14753 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
14754 return resultobj;
14755 fail:
14756 return NULL;
14757 }
14758
14759
14760 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14761 PyObject *resultobj = 0;
14762 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
14763 PyObject *arg2 = (PyObject *) 0 ;
14764 void *argp1 = 0 ;
14765 int res1 = 0 ;
14766 PyObject * obj0 = 0 ;
14767 PyObject * obj1 = 0 ;
14768 char * kwnames[] = {
14769 (char *) "self",(char *) "self", NULL
14770 };
14771
14772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
14773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
14774 if (!SWIG_IsOK(res1)) {
14775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
14776 }
14777 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
14778 arg2 = obj1;
14779 {
14780 PyThreadState* __tstate = wxPyBeginAllowThreads();
14781 (arg1)->_SetSelf(arg2);
14782 wxPyEndAllowThreads(__tstate);
14783 if (PyErr_Occurred()) SWIG_fail;
14784 }
14785 resultobj = SWIG_Py_Void();
14786 return resultobj;
14787 fail:
14788 return NULL;
14789 }
14790
14791
14792 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14793 PyObject *obj;
14794 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14795 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
14796 return SWIG_Py_Void();
14797 }
14798
14799 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14800 return SWIG_Python_InitShadowInstance(args);
14801 }
14802
14803 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14804 PyObject *resultobj = 0;
14805 wxImageHistogram *result = 0 ;
14806
14807 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
14808 {
14809 PyThreadState* __tstate = wxPyBeginAllowThreads();
14810 result = (wxImageHistogram *)new wxImageHistogram();
14811 wxPyEndAllowThreads(__tstate);
14812 if (PyErr_Occurred()) SWIG_fail;
14813 }
14814 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
14815 return resultobj;
14816 fail:
14817 return NULL;
14818 }
14819
14820
14821 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14822 PyObject *resultobj = 0;
14823 byte arg1 ;
14824 byte arg2 ;
14825 byte arg3 ;
14826 unsigned long result;
14827 unsigned char val1 ;
14828 int ecode1 = 0 ;
14829 unsigned char val2 ;
14830 int ecode2 = 0 ;
14831 unsigned char val3 ;
14832 int ecode3 = 0 ;
14833 PyObject * obj0 = 0 ;
14834 PyObject * obj1 = 0 ;
14835 PyObject * obj2 = 0 ;
14836 char * kwnames[] = {
14837 (char *) "r",(char *) "g",(char *) "b", NULL
14838 };
14839
14840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14841 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
14842 if (!SWIG_IsOK(ecode1)) {
14843 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
14844 }
14845 arg1 = static_cast< byte >(val1);
14846 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14847 if (!SWIG_IsOK(ecode2)) {
14848 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
14849 }
14850 arg2 = static_cast< byte >(val2);
14851 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14852 if (!SWIG_IsOK(ecode3)) {
14853 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
14854 }
14855 arg3 = static_cast< byte >(val3);
14856 {
14857 PyThreadState* __tstate = wxPyBeginAllowThreads();
14858 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
14859 wxPyEndAllowThreads(__tstate);
14860 if (PyErr_Occurred()) SWIG_fail;
14861 }
14862 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14863 return resultobj;
14864 fail:
14865 return NULL;
14866 }
14867
14868
14869 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14870 PyObject *resultobj = 0;
14871 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14872 byte *arg2 = (byte *) 0 ;
14873 byte *arg3 = (byte *) 0 ;
14874 byte *arg4 = (byte *) 0 ;
14875 byte arg5 = (byte) 1 ;
14876 byte arg6 = (byte) 0 ;
14877 byte arg7 = (byte) 0 ;
14878 bool result;
14879 void *argp1 = 0 ;
14880 int res1 = 0 ;
14881 byte temp2 ;
14882 int res2 = SWIG_TMPOBJ ;
14883 byte temp3 ;
14884 int res3 = SWIG_TMPOBJ ;
14885 byte temp4 ;
14886 int res4 = SWIG_TMPOBJ ;
14887 unsigned char val5 ;
14888 int ecode5 = 0 ;
14889 unsigned char val6 ;
14890 int ecode6 = 0 ;
14891 unsigned char val7 ;
14892 int ecode7 = 0 ;
14893 PyObject * obj0 = 0 ;
14894 PyObject * obj1 = 0 ;
14895 PyObject * obj2 = 0 ;
14896 PyObject * obj3 = 0 ;
14897 char * kwnames[] = {
14898 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14899 };
14900
14901 arg2 = &temp2;
14902 arg3 = &temp3;
14903 arg4 = &temp4;
14904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14906 if (!SWIG_IsOK(res1)) {
14907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
14908 }
14909 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14910 if (obj1) {
14911 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14912 if (!SWIG_IsOK(ecode5)) {
14913 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14914 }
14915 arg5 = static_cast< byte >(val5);
14916 }
14917 if (obj2) {
14918 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14919 if (!SWIG_IsOK(ecode6)) {
14920 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14921 }
14922 arg6 = static_cast< byte >(val6);
14923 }
14924 if (obj3) {
14925 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14926 if (!SWIG_IsOK(ecode7)) {
14927 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14928 }
14929 arg7 = static_cast< byte >(val7);
14930 }
14931 {
14932 PyThreadState* __tstate = wxPyBeginAllowThreads();
14933 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14934 wxPyEndAllowThreads(__tstate);
14935 if (PyErr_Occurred()) SWIG_fail;
14936 }
14937 {
14938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14939 }
14940 if (SWIG_IsTmpObj(res2)) {
14941 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14942 } else {
14943 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14944 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14945 }
14946 if (SWIG_IsTmpObj(res3)) {
14947 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14948 } else {
14949 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14950 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14951 }
14952 if (SWIG_IsTmpObj(res4)) {
14953 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14954 } else {
14955 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14956 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14957 }
14958 return resultobj;
14959 fail:
14960 return NULL;
14961 }
14962
14963
14964 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14965 PyObject *resultobj = 0;
14966 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14967 unsigned long arg2 ;
14968 unsigned long result;
14969 void *argp1 = 0 ;
14970 int res1 = 0 ;
14971 unsigned long val2 ;
14972 int ecode2 = 0 ;
14973 PyObject * obj0 = 0 ;
14974 PyObject * obj1 = 0 ;
14975 char * kwnames[] = {
14976 (char *) "self",(char *) "key", NULL
14977 };
14978
14979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
14980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14981 if (!SWIG_IsOK(res1)) {
14982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
14983 }
14984 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14985 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
14986 if (!SWIG_IsOK(ecode2)) {
14987 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
14988 }
14989 arg2 = static_cast< unsigned long >(val2);
14990 {
14991 PyThreadState* __tstate = wxPyBeginAllowThreads();
14992 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
14993 wxPyEndAllowThreads(__tstate);
14994 if (PyErr_Occurred()) SWIG_fail;
14995 }
14996 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14997 return resultobj;
14998 fail:
14999 return NULL;
15000 }
15001
15002
15003 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15004 PyObject *resultobj = 0;
15005 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
15006 byte arg2 ;
15007 byte arg3 ;
15008 byte arg4 ;
15009 unsigned long result;
15010 void *argp1 = 0 ;
15011 int res1 = 0 ;
15012 unsigned char val2 ;
15013 int ecode2 = 0 ;
15014 unsigned char val3 ;
15015 int ecode3 = 0 ;
15016 unsigned char val4 ;
15017 int ecode4 = 0 ;
15018 PyObject * obj0 = 0 ;
15019 PyObject * obj1 = 0 ;
15020 PyObject * obj2 = 0 ;
15021 PyObject * obj3 = 0 ;
15022 char * kwnames[] = {
15023 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15024 };
15025
15026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
15028 if (!SWIG_IsOK(res1)) {
15029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
15030 }
15031 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
15032 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15033 if (!SWIG_IsOK(ecode2)) {
15034 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
15035 }
15036 arg2 = static_cast< byte >(val2);
15037 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15038 if (!SWIG_IsOK(ecode3)) {
15039 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
15040 }
15041 arg3 = static_cast< byte >(val3);
15042 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15043 if (!SWIG_IsOK(ecode4)) {
15044 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
15045 }
15046 arg4 = static_cast< byte >(val4);
15047 {
15048 PyThreadState* __tstate = wxPyBeginAllowThreads();
15049 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
15050 wxPyEndAllowThreads(__tstate);
15051 if (PyErr_Occurred()) SWIG_fail;
15052 }
15053 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
15054 return resultobj;
15055 fail:
15056 return NULL;
15057 }
15058
15059
15060 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15061 PyObject *resultobj = 0;
15062 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
15063 wxColour *arg2 = 0 ;
15064 unsigned long result;
15065 void *argp1 = 0 ;
15066 int res1 = 0 ;
15067 wxColour temp2 ;
15068 PyObject * obj0 = 0 ;
15069 PyObject * obj1 = 0 ;
15070 char * kwnames[] = {
15071 (char *) "self",(char *) "colour", NULL
15072 };
15073
15074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
15075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
15076 if (!SWIG_IsOK(res1)) {
15077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
15078 }
15079 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
15080 {
15081 arg2 = &temp2;
15082 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
15083 }
15084 {
15085 PyThreadState* __tstate = wxPyBeginAllowThreads();
15086 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
15087 wxPyEndAllowThreads(__tstate);
15088 if (PyErr_Occurred()) SWIG_fail;
15089 }
15090 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
15091 return resultobj;
15092 fail:
15093 return NULL;
15094 }
15095
15096
15097 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15098 PyObject *obj;
15099 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15100 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
15101 return SWIG_Py_Void();
15102 }
15103
15104 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15105 return SWIG_Python_InitShadowInstance(args);
15106 }
15107
15108 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15109 PyObject *resultobj = 0;
15110 byte arg1 = (byte) 0 ;
15111 byte arg2 = (byte) 0 ;
15112 byte arg3 = (byte) 0 ;
15113 wxImage_RGBValue *result = 0 ;
15114 unsigned char val1 ;
15115 int ecode1 = 0 ;
15116 unsigned char val2 ;
15117 int ecode2 = 0 ;
15118 unsigned char val3 ;
15119 int ecode3 = 0 ;
15120 PyObject * obj0 = 0 ;
15121 PyObject * obj1 = 0 ;
15122 PyObject * obj2 = 0 ;
15123 char * kwnames[] = {
15124 (char *) "r",(char *) "g",(char *) "b", NULL
15125 };
15126
15127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15128 if (obj0) {
15129 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
15130 if (!SWIG_IsOK(ecode1)) {
15131 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
15132 }
15133 arg1 = static_cast< byte >(val1);
15134 }
15135 if (obj1) {
15136 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15137 if (!SWIG_IsOK(ecode2)) {
15138 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
15139 }
15140 arg2 = static_cast< byte >(val2);
15141 }
15142 if (obj2) {
15143 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15144 if (!SWIG_IsOK(ecode3)) {
15145 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
15146 }
15147 arg3 = static_cast< byte >(val3);
15148 }
15149 {
15150 PyThreadState* __tstate = wxPyBeginAllowThreads();
15151 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
15152 wxPyEndAllowThreads(__tstate);
15153 if (PyErr_Occurred()) SWIG_fail;
15154 }
15155 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
15156 return resultobj;
15157 fail:
15158 return NULL;
15159 }
15160
15161
15162 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15163 PyObject *resultobj = 0;
15164 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15165 byte arg2 ;
15166 void *argp1 = 0 ;
15167 int res1 = 0 ;
15168 unsigned char val2 ;
15169 int ecode2 = 0 ;
15170 PyObject *swig_obj[2] ;
15171
15172 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
15173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15174 if (!SWIG_IsOK(res1)) {
15175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15176 }
15177 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15178 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15179 if (!SWIG_IsOK(ecode2)) {
15180 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
15181 }
15182 arg2 = static_cast< byte >(val2);
15183 if (arg1) (arg1)->red = arg2;
15184
15185 resultobj = SWIG_Py_Void();
15186 return resultobj;
15187 fail:
15188 return NULL;
15189 }
15190
15191
15192 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15193 PyObject *resultobj = 0;
15194 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15195 byte result;
15196 void *argp1 = 0 ;
15197 int res1 = 0 ;
15198 PyObject *swig_obj[1] ;
15199
15200 if (!args) SWIG_fail;
15201 swig_obj[0] = args;
15202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15203 if (!SWIG_IsOK(res1)) {
15204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15205 }
15206 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15207 result = (byte) ((arg1)->red);
15208 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15209 return resultobj;
15210 fail:
15211 return NULL;
15212 }
15213
15214
15215 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15216 PyObject *resultobj = 0;
15217 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15218 byte arg2 ;
15219 void *argp1 = 0 ;
15220 int res1 = 0 ;
15221 unsigned char val2 ;
15222 int ecode2 = 0 ;
15223 PyObject *swig_obj[2] ;
15224
15225 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
15226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15227 if (!SWIG_IsOK(res1)) {
15228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15229 }
15230 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15231 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15232 if (!SWIG_IsOK(ecode2)) {
15233 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
15234 }
15235 arg2 = static_cast< byte >(val2);
15236 if (arg1) (arg1)->green = arg2;
15237
15238 resultobj = SWIG_Py_Void();
15239 return resultobj;
15240 fail:
15241 return NULL;
15242 }
15243
15244
15245 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15246 PyObject *resultobj = 0;
15247 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15248 byte result;
15249 void *argp1 = 0 ;
15250 int res1 = 0 ;
15251 PyObject *swig_obj[1] ;
15252
15253 if (!args) SWIG_fail;
15254 swig_obj[0] = args;
15255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15256 if (!SWIG_IsOK(res1)) {
15257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15258 }
15259 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15260 result = (byte) ((arg1)->green);
15261 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15262 return resultobj;
15263 fail:
15264 return NULL;
15265 }
15266
15267
15268 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15269 PyObject *resultobj = 0;
15270 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15271 byte arg2 ;
15272 void *argp1 = 0 ;
15273 int res1 = 0 ;
15274 unsigned char val2 ;
15275 int ecode2 = 0 ;
15276 PyObject *swig_obj[2] ;
15277
15278 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
15279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15280 if (!SWIG_IsOK(res1)) {
15281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15282 }
15283 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15284 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15285 if (!SWIG_IsOK(ecode2)) {
15286 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
15287 }
15288 arg2 = static_cast< byte >(val2);
15289 if (arg1) (arg1)->blue = arg2;
15290
15291 resultobj = SWIG_Py_Void();
15292 return resultobj;
15293 fail:
15294 return NULL;
15295 }
15296
15297
15298 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15299 PyObject *resultobj = 0;
15300 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15301 byte result;
15302 void *argp1 = 0 ;
15303 int res1 = 0 ;
15304 PyObject *swig_obj[1] ;
15305
15306 if (!args) SWIG_fail;
15307 swig_obj[0] = args;
15308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15309 if (!SWIG_IsOK(res1)) {
15310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15311 }
15312 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15313 result = (byte) ((arg1)->blue);
15314 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15315 return resultobj;
15316 fail:
15317 return NULL;
15318 }
15319
15320
15321 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15322 PyObject *obj;
15323 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15324 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
15325 return SWIG_Py_Void();
15326 }
15327
15328 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15329 return SWIG_Python_InitShadowInstance(args);
15330 }
15331
15332 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15333 PyObject *resultobj = 0;
15334 double arg1 = (double) 0.0 ;
15335 double arg2 = (double) 0.0 ;
15336 double arg3 = (double) 0.0 ;
15337 wxImage_HSVValue *result = 0 ;
15338 double val1 ;
15339 int ecode1 = 0 ;
15340 double val2 ;
15341 int ecode2 = 0 ;
15342 double val3 ;
15343 int ecode3 = 0 ;
15344 PyObject * obj0 = 0 ;
15345 PyObject * obj1 = 0 ;
15346 PyObject * obj2 = 0 ;
15347 char * kwnames[] = {
15348 (char *) "h",(char *) "s",(char *) "v", NULL
15349 };
15350
15351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15352 if (obj0) {
15353 ecode1 = SWIG_AsVal_double(obj0, &val1);
15354 if (!SWIG_IsOK(ecode1)) {
15355 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
15356 }
15357 arg1 = static_cast< double >(val1);
15358 }
15359 if (obj1) {
15360 ecode2 = SWIG_AsVal_double(obj1, &val2);
15361 if (!SWIG_IsOK(ecode2)) {
15362 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
15363 }
15364 arg2 = static_cast< double >(val2);
15365 }
15366 if (obj2) {
15367 ecode3 = SWIG_AsVal_double(obj2, &val3);
15368 if (!SWIG_IsOK(ecode3)) {
15369 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
15370 }
15371 arg3 = static_cast< double >(val3);
15372 }
15373 {
15374 PyThreadState* __tstate = wxPyBeginAllowThreads();
15375 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
15376 wxPyEndAllowThreads(__tstate);
15377 if (PyErr_Occurred()) SWIG_fail;
15378 }
15379 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
15380 return resultobj;
15381 fail:
15382 return NULL;
15383 }
15384
15385
15386 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15387 PyObject *resultobj = 0;
15388 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15389 double arg2 ;
15390 void *argp1 = 0 ;
15391 int res1 = 0 ;
15392 double val2 ;
15393 int ecode2 = 0 ;
15394 PyObject *swig_obj[2] ;
15395
15396 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
15397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15398 if (!SWIG_IsOK(res1)) {
15399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15400 }
15401 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15402 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15403 if (!SWIG_IsOK(ecode2)) {
15404 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
15405 }
15406 arg2 = static_cast< double >(val2);
15407 if (arg1) (arg1)->hue = arg2;
15408
15409 resultobj = SWIG_Py_Void();
15410 return resultobj;
15411 fail:
15412 return NULL;
15413 }
15414
15415
15416 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15417 PyObject *resultobj = 0;
15418 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15419 double result;
15420 void *argp1 = 0 ;
15421 int res1 = 0 ;
15422 PyObject *swig_obj[1] ;
15423
15424 if (!args) SWIG_fail;
15425 swig_obj[0] = args;
15426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15427 if (!SWIG_IsOK(res1)) {
15428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15429 }
15430 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15431 result = (double) ((arg1)->hue);
15432 resultobj = SWIG_From_double(static_cast< double >(result));
15433 return resultobj;
15434 fail:
15435 return NULL;
15436 }
15437
15438
15439 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15440 PyObject *resultobj = 0;
15441 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15442 double arg2 ;
15443 void *argp1 = 0 ;
15444 int res1 = 0 ;
15445 double val2 ;
15446 int ecode2 = 0 ;
15447 PyObject *swig_obj[2] ;
15448
15449 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
15450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15451 if (!SWIG_IsOK(res1)) {
15452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15453 }
15454 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15455 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15456 if (!SWIG_IsOK(ecode2)) {
15457 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
15458 }
15459 arg2 = static_cast< double >(val2);
15460 if (arg1) (arg1)->saturation = arg2;
15461
15462 resultobj = SWIG_Py_Void();
15463 return resultobj;
15464 fail:
15465 return NULL;
15466 }
15467
15468
15469 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15470 PyObject *resultobj = 0;
15471 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15472 double result;
15473 void *argp1 = 0 ;
15474 int res1 = 0 ;
15475 PyObject *swig_obj[1] ;
15476
15477 if (!args) SWIG_fail;
15478 swig_obj[0] = args;
15479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15480 if (!SWIG_IsOK(res1)) {
15481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15482 }
15483 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15484 result = (double) ((arg1)->saturation);
15485 resultobj = SWIG_From_double(static_cast< double >(result));
15486 return resultobj;
15487 fail:
15488 return NULL;
15489 }
15490
15491
15492 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15493 PyObject *resultobj = 0;
15494 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15495 double arg2 ;
15496 void *argp1 = 0 ;
15497 int res1 = 0 ;
15498 double val2 ;
15499 int ecode2 = 0 ;
15500 PyObject *swig_obj[2] ;
15501
15502 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
15503 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15504 if (!SWIG_IsOK(res1)) {
15505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15506 }
15507 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15508 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15509 if (!SWIG_IsOK(ecode2)) {
15510 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
15511 }
15512 arg2 = static_cast< double >(val2);
15513 if (arg1) (arg1)->value = arg2;
15514
15515 resultobj = SWIG_Py_Void();
15516 return resultobj;
15517 fail:
15518 return NULL;
15519 }
15520
15521
15522 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15523 PyObject *resultobj = 0;
15524 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15525 double result;
15526 void *argp1 = 0 ;
15527 int res1 = 0 ;
15528 PyObject *swig_obj[1] ;
15529
15530 if (!args) SWIG_fail;
15531 swig_obj[0] = args;
15532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15533 if (!SWIG_IsOK(res1)) {
15534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15535 }
15536 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15537 result = (double) ((arg1)->value);
15538 resultobj = SWIG_From_double(static_cast< double >(result));
15539 return resultobj;
15540 fail:
15541 return NULL;
15542 }
15543
15544
15545 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15546 PyObject *obj;
15547 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15548 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
15549 return SWIG_Py_Void();
15550 }
15551
15552 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15553 return SWIG_Python_InitShadowInstance(args);
15554 }
15555
15556 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15557 PyObject *resultobj = 0;
15558 wxString *arg1 = 0 ;
15559 long arg2 = (long) wxBITMAP_TYPE_ANY ;
15560 int arg3 = (int) -1 ;
15561 wxImage *result = 0 ;
15562 bool temp1 = false ;
15563 long val2 ;
15564 int ecode2 = 0 ;
15565 int val3 ;
15566 int ecode3 = 0 ;
15567 PyObject * obj0 = 0 ;
15568 PyObject * obj1 = 0 ;
15569 PyObject * obj2 = 0 ;
15570 char * kwnames[] = {
15571 (char *) "name",(char *) "type",(char *) "index", NULL
15572 };
15573
15574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15575 {
15576 arg1 = wxString_in_helper(obj0);
15577 if (arg1 == NULL) SWIG_fail;
15578 temp1 = true;
15579 }
15580 if (obj1) {
15581 ecode2 = SWIG_AsVal_long(obj1, &val2);
15582 if (!SWIG_IsOK(ecode2)) {
15583 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
15584 }
15585 arg2 = static_cast< long >(val2);
15586 }
15587 if (obj2) {
15588 ecode3 = SWIG_AsVal_int(obj2, &val3);
15589 if (!SWIG_IsOK(ecode3)) {
15590 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
15591 }
15592 arg3 = static_cast< int >(val3);
15593 }
15594 {
15595 PyThreadState* __tstate = wxPyBeginAllowThreads();
15596 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
15597 wxPyEndAllowThreads(__tstate);
15598 if (PyErr_Occurred()) SWIG_fail;
15599 }
15600 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
15601 {
15602 if (temp1)
15603 delete arg1;
15604 }
15605 return resultobj;
15606 fail:
15607 {
15608 if (temp1)
15609 delete arg1;
15610 }
15611 return NULL;
15612 }
15613
15614
15615 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15616 PyObject *resultobj = 0;
15617 wxImage *arg1 = (wxImage *) 0 ;
15618 void *argp1 = 0 ;
15619 int res1 = 0 ;
15620 PyObject *swig_obj[1] ;
15621
15622 if (!args) SWIG_fail;
15623 swig_obj[0] = args;
15624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
15625 if (!SWIG_IsOK(res1)) {
15626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
15627 }
15628 arg1 = reinterpret_cast< wxImage * >(argp1);
15629 {
15630 PyThreadState* __tstate = wxPyBeginAllowThreads();
15631 delete arg1;
15632
15633 wxPyEndAllowThreads(__tstate);
15634 if (PyErr_Occurred()) SWIG_fail;
15635 }
15636 resultobj = SWIG_Py_Void();
15637 return resultobj;
15638 fail:
15639 return NULL;
15640 }
15641
15642
15643 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15644 PyObject *resultobj = 0;
15645 wxString *arg1 = 0 ;
15646 wxString *arg2 = 0 ;
15647 int arg3 = (int) -1 ;
15648 wxImage *result = 0 ;
15649 bool temp1 = false ;
15650 bool temp2 = false ;
15651 int val3 ;
15652 int ecode3 = 0 ;
15653 PyObject * obj0 = 0 ;
15654 PyObject * obj1 = 0 ;
15655 PyObject * obj2 = 0 ;
15656 char * kwnames[] = {
15657 (char *) "name",(char *) "mimetype",(char *) "index", NULL
15658 };
15659
15660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15661 {
15662 arg1 = wxString_in_helper(obj0);
15663 if (arg1 == NULL) SWIG_fail;
15664 temp1 = true;
15665 }
15666 {
15667 arg2 = wxString_in_helper(obj1);
15668 if (arg2 == NULL) SWIG_fail;
15669 temp2 = true;
15670 }
15671 if (obj2) {
15672 ecode3 = SWIG_AsVal_int(obj2, &val3);
15673 if (!SWIG_IsOK(ecode3)) {
15674 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
15675 }
15676 arg3 = static_cast< int >(val3);
15677 }
15678 {
15679 PyThreadState* __tstate = wxPyBeginAllowThreads();
15680 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
15681 wxPyEndAllowThreads(__tstate);
15682 if (PyErr_Occurred()) SWIG_fail;
15683 }
15684 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15685 {
15686 if (temp1)
15687 delete arg1;
15688 }
15689 {
15690 if (temp2)
15691 delete arg2;
15692 }
15693 return resultobj;
15694 fail:
15695 {
15696 if (temp1)
15697 delete arg1;
15698 }
15699 {
15700 if (temp2)
15701 delete arg2;
15702 }
15703 return NULL;
15704 }
15705
15706
15707 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15708 PyObject *resultobj = 0;
15709 wxInputStream *arg1 = 0 ;
15710 long arg2 = (long) wxBITMAP_TYPE_ANY ;
15711 int arg3 = (int) -1 ;
15712 wxImage *result = 0 ;
15713 wxPyInputStream *temp1 ;
15714 bool created1 ;
15715 long val2 ;
15716 int ecode2 = 0 ;
15717 int val3 ;
15718 int ecode3 = 0 ;
15719 PyObject * obj0 = 0 ;
15720 PyObject * obj1 = 0 ;
15721 PyObject * obj2 = 0 ;
15722 char * kwnames[] = {
15723 (char *) "stream",(char *) "type",(char *) "index", NULL
15724 };
15725
15726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15727 {
15728 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15729 arg1 = temp1->m_wxis;
15730 created1 = false;
15731 } else {
15732 PyErr_Clear(); // clear the failure of the wxPyConvert above
15733 arg1 = wxPyCBInputStream_create(obj0, false);
15734 if (arg1 == NULL) {
15735 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15736 SWIG_fail;
15737 }
15738 created1 = true;
15739 }
15740 }
15741 if (obj1) {
15742 ecode2 = SWIG_AsVal_long(obj1, &val2);
15743 if (!SWIG_IsOK(ecode2)) {
15744 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
15745 }
15746 arg2 = static_cast< long >(val2);
15747 }
15748 if (obj2) {
15749 ecode3 = SWIG_AsVal_int(obj2, &val3);
15750 if (!SWIG_IsOK(ecode3)) {
15751 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
15752 }
15753 arg3 = static_cast< int >(val3);
15754 }
15755 {
15756 PyThreadState* __tstate = wxPyBeginAllowThreads();
15757 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
15758 wxPyEndAllowThreads(__tstate);
15759 if (PyErr_Occurred()) SWIG_fail;
15760 }
15761 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15762 {
15763 if (created1) delete arg1;
15764 }
15765 return resultobj;
15766 fail:
15767 {
15768 if (created1) delete arg1;
15769 }
15770 return NULL;
15771 }
15772
15773
15774 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15775 PyObject *resultobj = 0;
15776 wxInputStream *arg1 = 0 ;
15777 wxString *arg2 = 0 ;
15778 int arg3 = (int) -1 ;
15779 wxImage *result = 0 ;
15780 wxPyInputStream *temp1 ;
15781 bool created1 ;
15782 bool temp2 = false ;
15783 int val3 ;
15784 int ecode3 = 0 ;
15785 PyObject * obj0 = 0 ;
15786 PyObject * obj1 = 0 ;
15787 PyObject * obj2 = 0 ;
15788 char * kwnames[] = {
15789 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
15790 };
15791
15792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15793 {
15794 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15795 arg1 = temp1->m_wxis;
15796 created1 = false;
15797 } else {
15798 PyErr_Clear(); // clear the failure of the wxPyConvert above
15799 arg1 = wxPyCBInputStream_create(obj0, false);
15800 if (arg1 == NULL) {
15801 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15802 SWIG_fail;
15803 }
15804 created1 = true;
15805 }
15806 }
15807 {
15808 arg2 = wxString_in_helper(obj1);
15809 if (arg2 == NULL) SWIG_fail;
15810 temp2 = true;
15811 }
15812 if (obj2) {
15813 ecode3 = SWIG_AsVal_int(obj2, &val3);
15814 if (!SWIG_IsOK(ecode3)) {
15815 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
15816 }
15817 arg3 = static_cast< int >(val3);
15818 }
15819 {
15820 PyThreadState* __tstate = wxPyBeginAllowThreads();
15821 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
15822 wxPyEndAllowThreads(__tstate);
15823 if (PyErr_Occurred()) SWIG_fail;
15824 }
15825 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15826 {
15827 if (created1) delete arg1;
15828 }
15829 {
15830 if (temp2)
15831 delete arg2;
15832 }
15833 return resultobj;
15834 fail:
15835 {
15836 if (created1) delete arg1;
15837 }
15838 {
15839 if (temp2)
15840 delete arg2;
15841 }
15842 return NULL;
15843 }
15844
15845
15846 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15847 PyObject *resultobj = 0;
15848 int arg1 = (int) 0 ;
15849 int arg2 = (int) 0 ;
15850 bool arg3 = (bool) true ;
15851 wxImage *result = 0 ;
15852 int val1 ;
15853 int ecode1 = 0 ;
15854 int val2 ;
15855 int ecode2 = 0 ;
15856 bool val3 ;
15857 int ecode3 = 0 ;
15858 PyObject * obj0 = 0 ;
15859 PyObject * obj1 = 0 ;
15860 PyObject * obj2 = 0 ;
15861 char * kwnames[] = {
15862 (char *) "width",(char *) "height",(char *) "clear", NULL
15863 };
15864
15865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15866 if (obj0) {
15867 ecode1 = SWIG_AsVal_int(obj0, &val1);
15868 if (!SWIG_IsOK(ecode1)) {
15869 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
15870 }
15871 arg1 = static_cast< int >(val1);
15872 }
15873 if (obj1) {
15874 ecode2 = SWIG_AsVal_int(obj1, &val2);
15875 if (!SWIG_IsOK(ecode2)) {
15876 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
15877 }
15878 arg2 = static_cast< int >(val2);
15879 }
15880 if (obj2) {
15881 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15882 if (!SWIG_IsOK(ecode3)) {
15883 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
15884 }
15885 arg3 = static_cast< bool >(val3);
15886 }
15887 {
15888 PyThreadState* __tstate = wxPyBeginAllowThreads();
15889 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
15890 wxPyEndAllowThreads(__tstate);
15891 if (PyErr_Occurred()) SWIG_fail;
15892 }
15893 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15894 return resultobj;
15895 fail:
15896 return NULL;
15897 }
15898
15899
15900 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15901 PyObject *resultobj = 0;
15902 wxBitmap *arg1 = 0 ;
15903 wxImage *result = 0 ;
15904 void *argp1 = 0 ;
15905 int res1 = 0 ;
15906 PyObject * obj0 = 0 ;
15907 char * kwnames[] = {
15908 (char *) "bitmap", NULL
15909 };
15910
15911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
15912 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
15913 if (!SWIG_IsOK(res1)) {
15914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
15915 }
15916 if (!argp1) {
15917 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
15918 }
15919 arg1 = reinterpret_cast< wxBitmap * >(argp1);
15920 {
15921 if (!wxPyCheckForApp()) SWIG_fail;
15922 PyThreadState* __tstate = wxPyBeginAllowThreads();
15923 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
15924 wxPyEndAllowThreads(__tstate);
15925 if (PyErr_Occurred()) SWIG_fail;
15926 }
15927 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15928 return resultobj;
15929 fail:
15930 return NULL;
15931 }
15932
15933
15934 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15935 PyObject *resultobj = 0;
15936 int arg1 ;
15937 int arg2 ;
15938 buffer arg3 ;
15939 int arg4 ;
15940 wxImage *result = 0 ;
15941 int val1 ;
15942 int ecode1 = 0 ;
15943 int val2 ;
15944 int ecode2 = 0 ;
15945 Py_ssize_t temp3 ;
15946 PyObject * obj0 = 0 ;
15947 PyObject * obj1 = 0 ;
15948 PyObject * obj2 = 0 ;
15949 char * kwnames[] = {
15950 (char *) "width",(char *) "height",(char *) "data", NULL
15951 };
15952
15953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15954 ecode1 = SWIG_AsVal_int(obj0, &val1);
15955 if (!SWIG_IsOK(ecode1)) {
15956 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
15957 }
15958 arg1 = static_cast< int >(val1);
15959 ecode2 = SWIG_AsVal_int(obj1, &val2);
15960 if (!SWIG_IsOK(ecode2)) {
15961 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
15962 }
15963 arg2 = static_cast< int >(val2);
15964 {
15965 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
15966 arg4 = (int)temp3;
15967 }
15968 {
15969 PyThreadState* __tstate = wxPyBeginAllowThreads();
15970 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
15971 wxPyEndAllowThreads(__tstate);
15972 if (PyErr_Occurred()) SWIG_fail;
15973 }
15974 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15975 return resultobj;
15976 fail:
15977 return NULL;
15978 }
15979
15980
15981 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15982 PyObject *resultobj = 0;
15983 int arg1 ;
15984 int arg2 ;
15985 buffer arg3 ;
15986 int arg4 ;
15987 buffer arg5 ;
15988 int arg6 ;
15989 wxImage *result = 0 ;
15990 int val1 ;
15991 int ecode1 = 0 ;
15992 int val2 ;
15993 int ecode2 = 0 ;
15994 Py_ssize_t temp3 ;
15995 Py_ssize_t temp5 ;
15996 PyObject * obj0 = 0 ;
15997 PyObject * obj1 = 0 ;
15998 PyObject * obj2 = 0 ;
15999 PyObject * obj3 = 0 ;
16000 char * kwnames[] = {
16001 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
16002 };
16003
16004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16005 ecode1 = SWIG_AsVal_int(obj0, &val1);
16006 if (!SWIG_IsOK(ecode1)) {
16007 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
16008 }
16009 arg1 = static_cast< int >(val1);
16010 ecode2 = SWIG_AsVal_int(obj1, &val2);
16011 if (!SWIG_IsOK(ecode2)) {
16012 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
16013 }
16014 arg2 = static_cast< int >(val2);
16015 {
16016 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
16017 arg4 = (int)temp3;
16018 }
16019 {
16020 if (obj3 != Py_None) {
16021 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
16022 arg6 = (int)temp5;
16023 }
16024 }
16025 {
16026 PyThreadState* __tstate = wxPyBeginAllowThreads();
16027 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
16028 wxPyEndAllowThreads(__tstate);
16029 if (PyErr_Occurred()) SWIG_fail;
16030 }
16031 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16032 return resultobj;
16033 fail:
16034 return NULL;
16035 }
16036
16037
16038 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16039 PyObject *resultobj = 0;
16040 wxImage *arg1 = (wxImage *) 0 ;
16041 int arg2 ;
16042 int arg3 ;
16043 bool arg4 = (bool) true ;
16044 void *argp1 = 0 ;
16045 int res1 = 0 ;
16046 int val2 ;
16047 int ecode2 = 0 ;
16048 int val3 ;
16049 int ecode3 = 0 ;
16050 bool val4 ;
16051 int ecode4 = 0 ;
16052 PyObject * obj0 = 0 ;
16053 PyObject * obj1 = 0 ;
16054 PyObject * obj2 = 0 ;
16055 PyObject * obj3 = 0 ;
16056 char * kwnames[] = {
16057 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
16058 };
16059
16060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16062 if (!SWIG_IsOK(res1)) {
16063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
16064 }
16065 arg1 = reinterpret_cast< wxImage * >(argp1);
16066 ecode2 = SWIG_AsVal_int(obj1, &val2);
16067 if (!SWIG_IsOK(ecode2)) {
16068 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
16069 }
16070 arg2 = static_cast< int >(val2);
16071 ecode3 = SWIG_AsVal_int(obj2, &val3);
16072 if (!SWIG_IsOK(ecode3)) {
16073 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
16074 }
16075 arg3 = static_cast< int >(val3);
16076 if (obj3) {
16077 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16078 if (!SWIG_IsOK(ecode4)) {
16079 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
16080 }
16081 arg4 = static_cast< bool >(val4);
16082 }
16083 {
16084 PyThreadState* __tstate = wxPyBeginAllowThreads();
16085 (arg1)->Create(arg2,arg3,arg4);
16086 wxPyEndAllowThreads(__tstate);
16087 if (PyErr_Occurred()) SWIG_fail;
16088 }
16089 resultobj = SWIG_Py_Void();
16090 return resultobj;
16091 fail:
16092 return NULL;
16093 }
16094
16095
16096 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16097 PyObject *resultobj = 0;
16098 wxImage *arg1 = (wxImage *) 0 ;
16099 void *argp1 = 0 ;
16100 int res1 = 0 ;
16101 PyObject *swig_obj[1] ;
16102
16103 if (!args) SWIG_fail;
16104 swig_obj[0] = args;
16105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16106 if (!SWIG_IsOK(res1)) {
16107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
16108 }
16109 arg1 = reinterpret_cast< wxImage * >(argp1);
16110 {
16111 PyThreadState* __tstate = wxPyBeginAllowThreads();
16112 (arg1)->Destroy();
16113 wxPyEndAllowThreads(__tstate);
16114 if (PyErr_Occurred()) SWIG_fail;
16115 }
16116 resultobj = SWIG_Py_Void();
16117 return resultobj;
16118 fail:
16119 return NULL;
16120 }
16121
16122
16123 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16124 PyObject *resultobj = 0;
16125 wxImage *arg1 = (wxImage *) 0 ;
16126 int arg2 ;
16127 int arg3 ;
16128 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
16129 SwigValueWrapper<wxImage > result;
16130 void *argp1 = 0 ;
16131 int res1 = 0 ;
16132 int val2 ;
16133 int ecode2 = 0 ;
16134 int val3 ;
16135 int ecode3 = 0 ;
16136 int val4 ;
16137 int ecode4 = 0 ;
16138 PyObject * obj0 = 0 ;
16139 PyObject * obj1 = 0 ;
16140 PyObject * obj2 = 0 ;
16141 PyObject * obj3 = 0 ;
16142 char * kwnames[] = {
16143 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
16144 };
16145
16146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Scale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16148 if (!SWIG_IsOK(res1)) {
16149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
16150 }
16151 arg1 = reinterpret_cast< wxImage * >(argp1);
16152 ecode2 = SWIG_AsVal_int(obj1, &val2);
16153 if (!SWIG_IsOK(ecode2)) {
16154 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
16155 }
16156 arg2 = static_cast< int >(val2);
16157 ecode3 = SWIG_AsVal_int(obj2, &val3);
16158 if (!SWIG_IsOK(ecode3)) {
16159 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
16160 }
16161 arg3 = static_cast< int >(val3);
16162 if (obj3) {
16163 ecode4 = SWIG_AsVal_int(obj3, &val4);
16164 if (!SWIG_IsOK(ecode4)) {
16165 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Scale" "', expected argument " "4"" of type '" "int""'");
16166 }
16167 arg4 = static_cast< int >(val4);
16168 }
16169 {
16170 PyThreadState* __tstate = wxPyBeginAllowThreads();
16171 result = (arg1)->Scale(arg2,arg3,arg4);
16172 wxPyEndAllowThreads(__tstate);
16173 if (PyErr_Occurred()) SWIG_fail;
16174 }
16175 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16176 return resultobj;
16177 fail:
16178 return NULL;
16179 }
16180
16181
16182 SWIGINTERN PyObject *_wrap_Image_ResampleBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16183 PyObject *resultobj = 0;
16184 wxImage *arg1 = (wxImage *) 0 ;
16185 int arg2 ;
16186 int arg3 ;
16187 SwigValueWrapper<wxImage > result;
16188 void *argp1 = 0 ;
16189 int res1 = 0 ;
16190 int val2 ;
16191 int ecode2 = 0 ;
16192 int val3 ;
16193 int ecode3 = 0 ;
16194 PyObject * obj0 = 0 ;
16195 PyObject * obj1 = 0 ;
16196 PyObject * obj2 = 0 ;
16197 char * kwnames[] = {
16198 (char *) "self",(char *) "width",(char *) "height", NULL
16199 };
16200
16201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBox",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16203 if (!SWIG_IsOK(res1)) {
16204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBox" "', expected argument " "1"" of type '" "wxImage const *""'");
16205 }
16206 arg1 = reinterpret_cast< wxImage * >(argp1);
16207 ecode2 = SWIG_AsVal_int(obj1, &val2);
16208 if (!SWIG_IsOK(ecode2)) {
16209 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBox" "', expected argument " "2"" of type '" "int""'");
16210 }
16211 arg2 = static_cast< int >(val2);
16212 ecode3 = SWIG_AsVal_int(obj2, &val3);
16213 if (!SWIG_IsOK(ecode3)) {
16214 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBox" "', expected argument " "3"" of type '" "int""'");
16215 }
16216 arg3 = static_cast< int >(val3);
16217 {
16218 PyThreadState* __tstate = wxPyBeginAllowThreads();
16219 result = ((wxImage const *)arg1)->ResampleBox(arg2,arg3);
16220 wxPyEndAllowThreads(__tstate);
16221 if (PyErr_Occurred()) SWIG_fail;
16222 }
16223 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16224 return resultobj;
16225 fail:
16226 return NULL;
16227 }
16228
16229
16230 SWIGINTERN PyObject *_wrap_Image_ResampleBicubic(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16231 PyObject *resultobj = 0;
16232 wxImage *arg1 = (wxImage *) 0 ;
16233 int arg2 ;
16234 int arg3 ;
16235 SwigValueWrapper<wxImage > result;
16236 void *argp1 = 0 ;
16237 int res1 = 0 ;
16238 int val2 ;
16239 int ecode2 = 0 ;
16240 int val3 ;
16241 int ecode3 = 0 ;
16242 PyObject * obj0 = 0 ;
16243 PyObject * obj1 = 0 ;
16244 PyObject * obj2 = 0 ;
16245 char * kwnames[] = {
16246 (char *) "self",(char *) "width",(char *) "height", NULL
16247 };
16248
16249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBicubic",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16251 if (!SWIG_IsOK(res1)) {
16252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBicubic" "', expected argument " "1"" of type '" "wxImage const *""'");
16253 }
16254 arg1 = reinterpret_cast< wxImage * >(argp1);
16255 ecode2 = SWIG_AsVal_int(obj1, &val2);
16256 if (!SWIG_IsOK(ecode2)) {
16257 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBicubic" "', expected argument " "2"" of type '" "int""'");
16258 }
16259 arg2 = static_cast< int >(val2);
16260 ecode3 = SWIG_AsVal_int(obj2, &val3);
16261 if (!SWIG_IsOK(ecode3)) {
16262 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBicubic" "', expected argument " "3"" of type '" "int""'");
16263 }
16264 arg3 = static_cast< int >(val3);
16265 {
16266 PyThreadState* __tstate = wxPyBeginAllowThreads();
16267 result = ((wxImage const *)arg1)->ResampleBicubic(arg2,arg3);
16268 wxPyEndAllowThreads(__tstate);
16269 if (PyErr_Occurred()) SWIG_fail;
16270 }
16271 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16272 return resultobj;
16273 fail:
16274 return NULL;
16275 }
16276
16277
16278 SWIGINTERN PyObject *_wrap_Image_Blur(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16279 PyObject *resultobj = 0;
16280 wxImage *arg1 = (wxImage *) 0 ;
16281 int arg2 ;
16282 SwigValueWrapper<wxImage > result;
16283 void *argp1 = 0 ;
16284 int res1 = 0 ;
16285 int val2 ;
16286 int ecode2 = 0 ;
16287 PyObject * obj0 = 0 ;
16288 PyObject * obj1 = 0 ;
16289 char * kwnames[] = {
16290 (char *) "self",(char *) "radius", NULL
16291 };
16292
16293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_Blur",kwnames,&obj0,&obj1)) SWIG_fail;
16294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16295 if (!SWIG_IsOK(res1)) {
16296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Blur" "', expected argument " "1"" of type '" "wxImage *""'");
16297 }
16298 arg1 = reinterpret_cast< wxImage * >(argp1);
16299 ecode2 = SWIG_AsVal_int(obj1, &val2);
16300 if (!SWIG_IsOK(ecode2)) {
16301 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Blur" "', expected argument " "2"" of type '" "int""'");
16302 }
16303 arg2 = static_cast< int >(val2);
16304 {
16305 PyThreadState* __tstate = wxPyBeginAllowThreads();
16306 result = (arg1)->Blur(arg2);
16307 wxPyEndAllowThreads(__tstate);
16308 if (PyErr_Occurred()) SWIG_fail;
16309 }
16310 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16311 return resultobj;
16312 fail:
16313 return NULL;
16314 }
16315
16316
16317 SWIGINTERN PyObject *_wrap_Image_BlurHorizontal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16318 PyObject *resultobj = 0;
16319 wxImage *arg1 = (wxImage *) 0 ;
16320 int arg2 ;
16321 SwigValueWrapper<wxImage > result;
16322 void *argp1 = 0 ;
16323 int res1 = 0 ;
16324 int val2 ;
16325 int ecode2 = 0 ;
16326 PyObject * obj0 = 0 ;
16327 PyObject * obj1 = 0 ;
16328 char * kwnames[] = {
16329 (char *) "self",(char *) "radius", NULL
16330 };
16331
16332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurHorizontal",kwnames,&obj0,&obj1)) SWIG_fail;
16333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16334 if (!SWIG_IsOK(res1)) {
16335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurHorizontal" "', expected argument " "1"" of type '" "wxImage *""'");
16336 }
16337 arg1 = reinterpret_cast< wxImage * >(argp1);
16338 ecode2 = SWIG_AsVal_int(obj1, &val2);
16339 if (!SWIG_IsOK(ecode2)) {
16340 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurHorizontal" "', expected argument " "2"" of type '" "int""'");
16341 }
16342 arg2 = static_cast< int >(val2);
16343 {
16344 PyThreadState* __tstate = wxPyBeginAllowThreads();
16345 result = (arg1)->BlurHorizontal(arg2);
16346 wxPyEndAllowThreads(__tstate);
16347 if (PyErr_Occurred()) SWIG_fail;
16348 }
16349 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16350 return resultobj;
16351 fail:
16352 return NULL;
16353 }
16354
16355
16356 SWIGINTERN PyObject *_wrap_Image_BlurVertical(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16357 PyObject *resultobj = 0;
16358 wxImage *arg1 = (wxImage *) 0 ;
16359 int arg2 ;
16360 SwigValueWrapper<wxImage > result;
16361 void *argp1 = 0 ;
16362 int res1 = 0 ;
16363 int val2 ;
16364 int ecode2 = 0 ;
16365 PyObject * obj0 = 0 ;
16366 PyObject * obj1 = 0 ;
16367 char * kwnames[] = {
16368 (char *) "self",(char *) "radius", NULL
16369 };
16370
16371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurVertical",kwnames,&obj0,&obj1)) SWIG_fail;
16372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16373 if (!SWIG_IsOK(res1)) {
16374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurVertical" "', expected argument " "1"" of type '" "wxImage *""'");
16375 }
16376 arg1 = reinterpret_cast< wxImage * >(argp1);
16377 ecode2 = SWIG_AsVal_int(obj1, &val2);
16378 if (!SWIG_IsOK(ecode2)) {
16379 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurVertical" "', expected argument " "2"" of type '" "int""'");
16380 }
16381 arg2 = static_cast< int >(val2);
16382 {
16383 PyThreadState* __tstate = wxPyBeginAllowThreads();
16384 result = (arg1)->BlurVertical(arg2);
16385 wxPyEndAllowThreads(__tstate);
16386 if (PyErr_Occurred()) SWIG_fail;
16387 }
16388 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16389 return resultobj;
16390 fail:
16391 return NULL;
16392 }
16393
16394
16395 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16396 PyObject *resultobj = 0;
16397 wxImage *arg1 = (wxImage *) 0 ;
16398 int arg2 ;
16399 int arg3 ;
16400 SwigValueWrapper<wxImage > result;
16401 void *argp1 = 0 ;
16402 int res1 = 0 ;
16403 int val2 ;
16404 int ecode2 = 0 ;
16405 int val3 ;
16406 int ecode3 = 0 ;
16407 PyObject * obj0 = 0 ;
16408 PyObject * obj1 = 0 ;
16409 PyObject * obj2 = 0 ;
16410 char * kwnames[] = {
16411 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
16412 };
16413
16414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16416 if (!SWIG_IsOK(res1)) {
16417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
16418 }
16419 arg1 = reinterpret_cast< wxImage * >(argp1);
16420 ecode2 = SWIG_AsVal_int(obj1, &val2);
16421 if (!SWIG_IsOK(ecode2)) {
16422 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
16423 }
16424 arg2 = static_cast< int >(val2);
16425 ecode3 = SWIG_AsVal_int(obj2, &val3);
16426 if (!SWIG_IsOK(ecode3)) {
16427 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
16428 }
16429 arg3 = static_cast< int >(val3);
16430 {
16431 PyThreadState* __tstate = wxPyBeginAllowThreads();
16432 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
16433 wxPyEndAllowThreads(__tstate);
16434 if (PyErr_Occurred()) SWIG_fail;
16435 }
16436 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16437 return resultobj;
16438 fail:
16439 return NULL;
16440 }
16441
16442
16443 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16444 PyObject *resultobj = 0;
16445 wxImage *arg1 = (wxImage *) 0 ;
16446 int arg2 ;
16447 int arg3 ;
16448 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
16449 wxImage *result = 0 ;
16450 void *argp1 = 0 ;
16451 int res1 = 0 ;
16452 int val2 ;
16453 int ecode2 = 0 ;
16454 int val3 ;
16455 int ecode3 = 0 ;
16456 int val4 ;
16457 int ecode4 = 0 ;
16458 PyObject * obj0 = 0 ;
16459 PyObject * obj1 = 0 ;
16460 PyObject * obj2 = 0 ;
16461 PyObject * obj3 = 0 ;
16462 char * kwnames[] = {
16463 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
16464 };
16465
16466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Rescale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16468 if (!SWIG_IsOK(res1)) {
16469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
16470 }
16471 arg1 = reinterpret_cast< wxImage * >(argp1);
16472 ecode2 = SWIG_AsVal_int(obj1, &val2);
16473 if (!SWIG_IsOK(ecode2)) {
16474 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
16475 }
16476 arg2 = static_cast< int >(val2);
16477 ecode3 = SWIG_AsVal_int(obj2, &val3);
16478 if (!SWIG_IsOK(ecode3)) {
16479 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
16480 }
16481 arg3 = static_cast< int >(val3);
16482 if (obj3) {
16483 ecode4 = SWIG_AsVal_int(obj3, &val4);
16484 if (!SWIG_IsOK(ecode4)) {
16485 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rescale" "', expected argument " "4"" of type '" "int""'");
16486 }
16487 arg4 = static_cast< int >(val4);
16488 }
16489 {
16490 PyThreadState* __tstate = wxPyBeginAllowThreads();
16491 {
16492 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3,arg4);
16493 result = (wxImage *) &_result_ref;
16494 }
16495 wxPyEndAllowThreads(__tstate);
16496 if (PyErr_Occurred()) SWIG_fail;
16497 }
16498 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
16499 return resultobj;
16500 fail:
16501 return NULL;
16502 }
16503
16504
16505 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16506 PyObject *resultobj = 0;
16507 wxImage *arg1 = (wxImage *) 0 ;
16508 wxSize *arg2 = 0 ;
16509 wxPoint *arg3 = 0 ;
16510 int arg4 = (int) -1 ;
16511 int arg5 = (int) -1 ;
16512 int arg6 = (int) -1 ;
16513 wxImage *result = 0 ;
16514 void *argp1 = 0 ;
16515 int res1 = 0 ;
16516 wxSize temp2 ;
16517 wxPoint temp3 ;
16518 int val4 ;
16519 int ecode4 = 0 ;
16520 int val5 ;
16521 int ecode5 = 0 ;
16522 int val6 ;
16523 int ecode6 = 0 ;
16524 PyObject * obj0 = 0 ;
16525 PyObject * obj1 = 0 ;
16526 PyObject * obj2 = 0 ;
16527 PyObject * obj3 = 0 ;
16528 PyObject * obj4 = 0 ;
16529 PyObject * obj5 = 0 ;
16530 char * kwnames[] = {
16531 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
16532 };
16533
16534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
16535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16536 if (!SWIG_IsOK(res1)) {
16537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
16538 }
16539 arg1 = reinterpret_cast< wxImage * >(argp1);
16540 {
16541 arg2 = &temp2;
16542 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
16543 }
16544 {
16545 arg3 = &temp3;
16546 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
16547 }
16548 if (obj3) {
16549 ecode4 = SWIG_AsVal_int(obj3, &val4);
16550 if (!SWIG_IsOK(ecode4)) {
16551 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
16552 }
16553 arg4 = static_cast< int >(val4);
16554 }
16555 if (obj4) {
16556 ecode5 = SWIG_AsVal_int(obj4, &val5);
16557 if (!SWIG_IsOK(ecode5)) {
16558 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
16559 }
16560 arg5 = static_cast< int >(val5);
16561 }
16562 if (obj5) {
16563 ecode6 = SWIG_AsVal_int(obj5, &val6);
16564 if (!SWIG_IsOK(ecode6)) {
16565 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
16566 }
16567 arg6 = static_cast< int >(val6);
16568 }
16569 {
16570 PyThreadState* __tstate = wxPyBeginAllowThreads();
16571 {
16572 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
16573 result = (wxImage *) &_result_ref;
16574 }
16575 wxPyEndAllowThreads(__tstate);
16576 if (PyErr_Occurred()) SWIG_fail;
16577 }
16578 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
16579 return resultobj;
16580 fail:
16581 return NULL;
16582 }
16583
16584
16585 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16586 PyObject *resultobj = 0;
16587 wxImage *arg1 = (wxImage *) 0 ;
16588 int arg2 ;
16589 int arg3 ;
16590 byte arg4 ;
16591 byte arg5 ;
16592 byte arg6 ;
16593 void *argp1 = 0 ;
16594 int res1 = 0 ;
16595 int val2 ;
16596 int ecode2 = 0 ;
16597 int val3 ;
16598 int ecode3 = 0 ;
16599 unsigned char val4 ;
16600 int ecode4 = 0 ;
16601 unsigned char val5 ;
16602 int ecode5 = 0 ;
16603 unsigned char val6 ;
16604 int ecode6 = 0 ;
16605 PyObject * obj0 = 0 ;
16606 PyObject * obj1 = 0 ;
16607 PyObject * obj2 = 0 ;
16608 PyObject * obj3 = 0 ;
16609 PyObject * obj4 = 0 ;
16610 PyObject * obj5 = 0 ;
16611 char * kwnames[] = {
16612 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
16613 };
16614
16615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
16616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16617 if (!SWIG_IsOK(res1)) {
16618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
16619 }
16620 arg1 = reinterpret_cast< wxImage * >(argp1);
16621 ecode2 = SWIG_AsVal_int(obj1, &val2);
16622 if (!SWIG_IsOK(ecode2)) {
16623 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
16624 }
16625 arg2 = static_cast< int >(val2);
16626 ecode3 = SWIG_AsVal_int(obj2, &val3);
16627 if (!SWIG_IsOK(ecode3)) {
16628 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
16629 }
16630 arg3 = static_cast< int >(val3);
16631 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16632 if (!SWIG_IsOK(ecode4)) {
16633 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
16634 }
16635 arg4 = static_cast< byte >(val4);
16636 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16637 if (!SWIG_IsOK(ecode5)) {
16638 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
16639 }
16640 arg5 = static_cast< byte >(val5);
16641 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16642 if (!SWIG_IsOK(ecode6)) {
16643 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
16644 }
16645 arg6 = static_cast< byte >(val6);
16646 {
16647 PyThreadState* __tstate = wxPyBeginAllowThreads();
16648 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
16649 wxPyEndAllowThreads(__tstate);
16650 if (PyErr_Occurred()) SWIG_fail;
16651 }
16652 resultobj = SWIG_Py_Void();
16653 return resultobj;
16654 fail:
16655 return NULL;
16656 }
16657
16658
16659 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16660 PyObject *resultobj = 0;
16661 wxImage *arg1 = (wxImage *) 0 ;
16662 wxRect *arg2 = 0 ;
16663 byte arg3 ;
16664 byte arg4 ;
16665 byte arg5 ;
16666 void *argp1 = 0 ;
16667 int res1 = 0 ;
16668 wxRect temp2 ;
16669 unsigned char val3 ;
16670 int ecode3 = 0 ;
16671 unsigned char val4 ;
16672 int ecode4 = 0 ;
16673 unsigned char val5 ;
16674 int ecode5 = 0 ;
16675 PyObject * obj0 = 0 ;
16676 PyObject * obj1 = 0 ;
16677 PyObject * obj2 = 0 ;
16678 PyObject * obj3 = 0 ;
16679 PyObject * obj4 = 0 ;
16680 char * kwnames[] = {
16681 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
16682 };
16683
16684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16686 if (!SWIG_IsOK(res1)) {
16687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
16688 }
16689 arg1 = reinterpret_cast< wxImage * >(argp1);
16690 {
16691 arg2 = &temp2;
16692 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
16693 }
16694 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16695 if (!SWIG_IsOK(ecode3)) {
16696 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
16697 }
16698 arg3 = static_cast< byte >(val3);
16699 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16700 if (!SWIG_IsOK(ecode4)) {
16701 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
16702 }
16703 arg4 = static_cast< byte >(val4);
16704 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16705 if (!SWIG_IsOK(ecode5)) {
16706 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
16707 }
16708 arg5 = static_cast< byte >(val5);
16709 {
16710 PyThreadState* __tstate = wxPyBeginAllowThreads();
16711 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
16712 wxPyEndAllowThreads(__tstate);
16713 if (PyErr_Occurred()) SWIG_fail;
16714 }
16715 resultobj = SWIG_Py_Void();
16716 return resultobj;
16717 fail:
16718 return NULL;
16719 }
16720
16721
16722 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16723 PyObject *resultobj = 0;
16724 wxImage *arg1 = (wxImage *) 0 ;
16725 int arg2 ;
16726 int arg3 ;
16727 byte result;
16728 void *argp1 = 0 ;
16729 int res1 = 0 ;
16730 int val2 ;
16731 int ecode2 = 0 ;
16732 int val3 ;
16733 int ecode3 = 0 ;
16734 PyObject * obj0 = 0 ;
16735 PyObject * obj1 = 0 ;
16736 PyObject * obj2 = 0 ;
16737 char * kwnames[] = {
16738 (char *) "self",(char *) "x",(char *) "y", NULL
16739 };
16740
16741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16743 if (!SWIG_IsOK(res1)) {
16744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
16745 }
16746 arg1 = reinterpret_cast< wxImage * >(argp1);
16747 ecode2 = SWIG_AsVal_int(obj1, &val2);
16748 if (!SWIG_IsOK(ecode2)) {
16749 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
16750 }
16751 arg2 = static_cast< int >(val2);
16752 ecode3 = SWIG_AsVal_int(obj2, &val3);
16753 if (!SWIG_IsOK(ecode3)) {
16754 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
16755 }
16756 arg3 = static_cast< int >(val3);
16757 {
16758 PyThreadState* __tstate = wxPyBeginAllowThreads();
16759 result = (byte)(arg1)->GetRed(arg2,arg3);
16760 wxPyEndAllowThreads(__tstate);
16761 if (PyErr_Occurred()) SWIG_fail;
16762 }
16763 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16764 return resultobj;
16765 fail:
16766 return NULL;
16767 }
16768
16769
16770 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16771 PyObject *resultobj = 0;
16772 wxImage *arg1 = (wxImage *) 0 ;
16773 int arg2 ;
16774 int arg3 ;
16775 byte result;
16776 void *argp1 = 0 ;
16777 int res1 = 0 ;
16778 int val2 ;
16779 int ecode2 = 0 ;
16780 int val3 ;
16781 int ecode3 = 0 ;
16782 PyObject * obj0 = 0 ;
16783 PyObject * obj1 = 0 ;
16784 PyObject * obj2 = 0 ;
16785 char * kwnames[] = {
16786 (char *) "self",(char *) "x",(char *) "y", NULL
16787 };
16788
16789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16791 if (!SWIG_IsOK(res1)) {
16792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
16793 }
16794 arg1 = reinterpret_cast< wxImage * >(argp1);
16795 ecode2 = SWIG_AsVal_int(obj1, &val2);
16796 if (!SWIG_IsOK(ecode2)) {
16797 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
16798 }
16799 arg2 = static_cast< int >(val2);
16800 ecode3 = SWIG_AsVal_int(obj2, &val3);
16801 if (!SWIG_IsOK(ecode3)) {
16802 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
16803 }
16804 arg3 = static_cast< int >(val3);
16805 {
16806 PyThreadState* __tstate = wxPyBeginAllowThreads();
16807 result = (byte)(arg1)->GetGreen(arg2,arg3);
16808 wxPyEndAllowThreads(__tstate);
16809 if (PyErr_Occurred()) SWIG_fail;
16810 }
16811 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16812 return resultobj;
16813 fail:
16814 return NULL;
16815 }
16816
16817
16818 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16819 PyObject *resultobj = 0;
16820 wxImage *arg1 = (wxImage *) 0 ;
16821 int arg2 ;
16822 int arg3 ;
16823 byte result;
16824 void *argp1 = 0 ;
16825 int res1 = 0 ;
16826 int val2 ;
16827 int ecode2 = 0 ;
16828 int val3 ;
16829 int ecode3 = 0 ;
16830 PyObject * obj0 = 0 ;
16831 PyObject * obj1 = 0 ;
16832 PyObject * obj2 = 0 ;
16833 char * kwnames[] = {
16834 (char *) "self",(char *) "x",(char *) "y", NULL
16835 };
16836
16837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16839 if (!SWIG_IsOK(res1)) {
16840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
16841 }
16842 arg1 = reinterpret_cast< wxImage * >(argp1);
16843 ecode2 = SWIG_AsVal_int(obj1, &val2);
16844 if (!SWIG_IsOK(ecode2)) {
16845 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
16846 }
16847 arg2 = static_cast< int >(val2);
16848 ecode3 = SWIG_AsVal_int(obj2, &val3);
16849 if (!SWIG_IsOK(ecode3)) {
16850 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
16851 }
16852 arg3 = static_cast< int >(val3);
16853 {
16854 PyThreadState* __tstate = wxPyBeginAllowThreads();
16855 result = (byte)(arg1)->GetBlue(arg2,arg3);
16856 wxPyEndAllowThreads(__tstate);
16857 if (PyErr_Occurred()) SWIG_fail;
16858 }
16859 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16860 return resultobj;
16861 fail:
16862 return NULL;
16863 }
16864
16865
16866 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16867 PyObject *resultobj = 0;
16868 wxImage *arg1 = (wxImage *) 0 ;
16869 int arg2 ;
16870 int arg3 ;
16871 byte arg4 ;
16872 void *argp1 = 0 ;
16873 int res1 = 0 ;
16874 int val2 ;
16875 int ecode2 = 0 ;
16876 int val3 ;
16877 int ecode3 = 0 ;
16878 unsigned char val4 ;
16879 int ecode4 = 0 ;
16880 PyObject * obj0 = 0 ;
16881 PyObject * obj1 = 0 ;
16882 PyObject * obj2 = 0 ;
16883 PyObject * obj3 = 0 ;
16884 char * kwnames[] = {
16885 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
16886 };
16887
16888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16890 if (!SWIG_IsOK(res1)) {
16891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16892 }
16893 arg1 = reinterpret_cast< wxImage * >(argp1);
16894 ecode2 = SWIG_AsVal_int(obj1, &val2);
16895 if (!SWIG_IsOK(ecode2)) {
16896 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
16897 }
16898 arg2 = static_cast< int >(val2);
16899 ecode3 = SWIG_AsVal_int(obj2, &val3);
16900 if (!SWIG_IsOK(ecode3)) {
16901 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
16902 }
16903 arg3 = static_cast< int >(val3);
16904 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16905 if (!SWIG_IsOK(ecode4)) {
16906 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
16907 }
16908 arg4 = static_cast< byte >(val4);
16909 {
16910 PyThreadState* __tstate = wxPyBeginAllowThreads();
16911 (arg1)->SetAlpha(arg2,arg3,arg4);
16912 wxPyEndAllowThreads(__tstate);
16913 if (PyErr_Occurred()) SWIG_fail;
16914 }
16915 resultobj = SWIG_Py_Void();
16916 return resultobj;
16917 fail:
16918 return NULL;
16919 }
16920
16921
16922 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16923 PyObject *resultobj = 0;
16924 wxImage *arg1 = (wxImage *) 0 ;
16925 int arg2 ;
16926 int arg3 ;
16927 byte result;
16928 void *argp1 = 0 ;
16929 int res1 = 0 ;
16930 int val2 ;
16931 int ecode2 = 0 ;
16932 int val3 ;
16933 int ecode3 = 0 ;
16934 PyObject * obj0 = 0 ;
16935 PyObject * obj1 = 0 ;
16936 PyObject * obj2 = 0 ;
16937 char * kwnames[] = {
16938 (char *) "self",(char *) "x",(char *) "y", NULL
16939 };
16940
16941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16943 if (!SWIG_IsOK(res1)) {
16944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16945 }
16946 arg1 = reinterpret_cast< wxImage * >(argp1);
16947 ecode2 = SWIG_AsVal_int(obj1, &val2);
16948 if (!SWIG_IsOK(ecode2)) {
16949 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
16950 }
16951 arg2 = static_cast< int >(val2);
16952 ecode3 = SWIG_AsVal_int(obj2, &val3);
16953 if (!SWIG_IsOK(ecode3)) {
16954 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
16955 }
16956 arg3 = static_cast< int >(val3);
16957 {
16958 PyThreadState* __tstate = wxPyBeginAllowThreads();
16959 result = (byte)(arg1)->GetAlpha(arg2,arg3);
16960 wxPyEndAllowThreads(__tstate);
16961 if (PyErr_Occurred()) SWIG_fail;
16962 }
16963 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16964 return resultobj;
16965 fail:
16966 return NULL;
16967 }
16968
16969
16970 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16971 PyObject *resultobj = 0;
16972 wxImage *arg1 = (wxImage *) 0 ;
16973 bool result;
16974 void *argp1 = 0 ;
16975 int res1 = 0 ;
16976 PyObject *swig_obj[1] ;
16977
16978 if (!args) SWIG_fail;
16979 swig_obj[0] = args;
16980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16981 if (!SWIG_IsOK(res1)) {
16982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16983 }
16984 arg1 = reinterpret_cast< wxImage * >(argp1);
16985 {
16986 PyThreadState* __tstate = wxPyBeginAllowThreads();
16987 result = (bool)(arg1)->HasAlpha();
16988 wxPyEndAllowThreads(__tstate);
16989 if (PyErr_Occurred()) SWIG_fail;
16990 }
16991 {
16992 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16993 }
16994 return resultobj;
16995 fail:
16996 return NULL;
16997 }
16998
16999
17000 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17001 PyObject *resultobj = 0;
17002 wxImage *arg1 = (wxImage *) 0 ;
17003 void *argp1 = 0 ;
17004 int res1 = 0 ;
17005 PyObject *swig_obj[1] ;
17006
17007 if (!args) SWIG_fail;
17008 swig_obj[0] = args;
17009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17010 if (!SWIG_IsOK(res1)) {
17011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
17012 }
17013 arg1 = reinterpret_cast< wxImage * >(argp1);
17014 {
17015 PyThreadState* __tstate = wxPyBeginAllowThreads();
17016 (arg1)->InitAlpha();
17017 wxPyEndAllowThreads(__tstate);
17018 if (PyErr_Occurred()) SWIG_fail;
17019 }
17020 resultobj = SWIG_Py_Void();
17021 return resultobj;
17022 fail:
17023 return NULL;
17024 }
17025
17026
17027 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17028 PyObject *resultobj = 0;
17029 wxImage *arg1 = (wxImage *) 0 ;
17030 int arg2 ;
17031 int arg3 ;
17032 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
17033 bool result;
17034 void *argp1 = 0 ;
17035 int res1 = 0 ;
17036 int val2 ;
17037 int ecode2 = 0 ;
17038 int val3 ;
17039 int ecode3 = 0 ;
17040 unsigned char val4 ;
17041 int ecode4 = 0 ;
17042 PyObject * obj0 = 0 ;
17043 PyObject * obj1 = 0 ;
17044 PyObject * obj2 = 0 ;
17045 PyObject * obj3 = 0 ;
17046 char * kwnames[] = {
17047 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
17048 };
17049
17050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17052 if (!SWIG_IsOK(res1)) {
17053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
17054 }
17055 arg1 = reinterpret_cast< wxImage * >(argp1);
17056 ecode2 = SWIG_AsVal_int(obj1, &val2);
17057 if (!SWIG_IsOK(ecode2)) {
17058 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
17059 }
17060 arg2 = static_cast< int >(val2);
17061 ecode3 = SWIG_AsVal_int(obj2, &val3);
17062 if (!SWIG_IsOK(ecode3)) {
17063 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
17064 }
17065 arg3 = static_cast< int >(val3);
17066 if (obj3) {
17067 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17068 if (!SWIG_IsOK(ecode4)) {
17069 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
17070 }
17071 arg4 = static_cast< byte >(val4);
17072 }
17073 {
17074 PyThreadState* __tstate = wxPyBeginAllowThreads();
17075 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
17076 wxPyEndAllowThreads(__tstate);
17077 if (PyErr_Occurred()) SWIG_fail;
17078 }
17079 {
17080 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17081 }
17082 return resultobj;
17083 fail:
17084 return NULL;
17085 }
17086
17087
17088 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17089 PyObject *resultobj = 0;
17090 wxImage *arg1 = (wxImage *) 0 ;
17091 byte *arg2 = (byte *) 0 ;
17092 byte *arg3 = (byte *) 0 ;
17093 byte *arg4 = (byte *) 0 ;
17094 byte arg5 = (byte) 0 ;
17095 byte arg6 = (byte) 0 ;
17096 byte arg7 = (byte) 0 ;
17097 bool result;
17098 void *argp1 = 0 ;
17099 int res1 = 0 ;
17100 byte temp2 ;
17101 int res2 = SWIG_TMPOBJ ;
17102 byte temp3 ;
17103 int res3 = SWIG_TMPOBJ ;
17104 byte temp4 ;
17105 int res4 = SWIG_TMPOBJ ;
17106 unsigned char val5 ;
17107 int ecode5 = 0 ;
17108 unsigned char val6 ;
17109 int ecode6 = 0 ;
17110 unsigned char val7 ;
17111 int ecode7 = 0 ;
17112 PyObject * obj0 = 0 ;
17113 PyObject * obj1 = 0 ;
17114 PyObject * obj2 = 0 ;
17115 PyObject * obj3 = 0 ;
17116 char * kwnames[] = {
17117 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
17118 };
17119
17120 arg2 = &temp2;
17121 arg3 = &temp3;
17122 arg4 = &temp4;
17123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17125 if (!SWIG_IsOK(res1)) {
17126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
17127 }
17128 arg1 = reinterpret_cast< wxImage * >(argp1);
17129 if (obj1) {
17130 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
17131 if (!SWIG_IsOK(ecode5)) {
17132 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
17133 }
17134 arg5 = static_cast< byte >(val5);
17135 }
17136 if (obj2) {
17137 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
17138 if (!SWIG_IsOK(ecode6)) {
17139 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
17140 }
17141 arg6 = static_cast< byte >(val6);
17142 }
17143 if (obj3) {
17144 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
17145 if (!SWIG_IsOK(ecode7)) {
17146 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
17147 }
17148 arg7 = static_cast< byte >(val7);
17149 }
17150 {
17151 PyThreadState* __tstate = wxPyBeginAllowThreads();
17152 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
17153 wxPyEndAllowThreads(__tstate);
17154 if (PyErr_Occurred()) SWIG_fail;
17155 }
17156 {
17157 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17158 }
17159 if (SWIG_IsTmpObj(res2)) {
17160 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
17161 } else {
17162 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17163 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
17164 }
17165 if (SWIG_IsTmpObj(res3)) {
17166 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
17167 } else {
17168 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17169 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
17170 }
17171 if (SWIG_IsTmpObj(res4)) {
17172 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
17173 } else {
17174 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17175 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
17176 }
17177 return resultobj;
17178 fail:
17179 return NULL;
17180 }
17181
17182
17183 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17184 PyObject *resultobj = 0;
17185 wxImage *arg1 = (wxImage *) 0 ;
17186 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
17187 bool result;
17188 void *argp1 = 0 ;
17189 int res1 = 0 ;
17190 unsigned char val2 ;
17191 int ecode2 = 0 ;
17192 PyObject * obj0 = 0 ;
17193 PyObject * obj1 = 0 ;
17194 char * kwnames[] = {
17195 (char *) "self",(char *) "threshold", NULL
17196 };
17197
17198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
17199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17200 if (!SWIG_IsOK(res1)) {
17201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
17202 }
17203 arg1 = reinterpret_cast< wxImage * >(argp1);
17204 if (obj1) {
17205 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17206 if (!SWIG_IsOK(ecode2)) {
17207 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
17208 }
17209 arg2 = static_cast< byte >(val2);
17210 }
17211 {
17212 PyThreadState* __tstate = wxPyBeginAllowThreads();
17213 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
17214 wxPyEndAllowThreads(__tstate);
17215 if (PyErr_Occurred()) SWIG_fail;
17216 }
17217 {
17218 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17219 }
17220 return resultobj;
17221 fail:
17222 return NULL;
17223 }
17224
17225
17226 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17227 PyObject *resultobj = 0;
17228 wxImage *arg1 = (wxImage *) 0 ;
17229 byte arg2 ;
17230 byte arg3 ;
17231 byte arg4 ;
17232 bool result;
17233 void *argp1 = 0 ;
17234 int res1 = 0 ;
17235 unsigned char val2 ;
17236 int ecode2 = 0 ;
17237 unsigned char val3 ;
17238 int ecode3 = 0 ;
17239 unsigned char val4 ;
17240 int ecode4 = 0 ;
17241 PyObject * obj0 = 0 ;
17242 PyObject * obj1 = 0 ;
17243 PyObject * obj2 = 0 ;
17244 PyObject * obj3 = 0 ;
17245 char * kwnames[] = {
17246 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
17247 };
17248
17249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17251 if (!SWIG_IsOK(res1)) {
17252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
17253 }
17254 arg1 = reinterpret_cast< wxImage * >(argp1);
17255 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17256 if (!SWIG_IsOK(ecode2)) {
17257 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
17258 }
17259 arg2 = static_cast< byte >(val2);
17260 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17261 if (!SWIG_IsOK(ecode3)) {
17262 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
17263 }
17264 arg3 = static_cast< byte >(val3);
17265 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17266 if (!SWIG_IsOK(ecode4)) {
17267 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
17268 }
17269 arg4 = static_cast< byte >(val4);
17270 {
17271 PyThreadState* __tstate = wxPyBeginAllowThreads();
17272 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
17273 wxPyEndAllowThreads(__tstate);
17274 if (PyErr_Occurred()) SWIG_fail;
17275 }
17276 {
17277 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17278 }
17279 return resultobj;
17280 fail:
17281 return NULL;
17282 }
17283
17284
17285 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17286 PyObject *resultobj = 0;
17287 wxImage *arg1 = (wxImage *) 0 ;
17288 wxImage *arg2 = 0 ;
17289 byte arg3 ;
17290 byte arg4 ;
17291 byte arg5 ;
17292 bool result;
17293 void *argp1 = 0 ;
17294 int res1 = 0 ;
17295 void *argp2 = 0 ;
17296 int res2 = 0 ;
17297 unsigned char val3 ;
17298 int ecode3 = 0 ;
17299 unsigned char val4 ;
17300 int ecode4 = 0 ;
17301 unsigned char val5 ;
17302 int ecode5 = 0 ;
17303 PyObject * obj0 = 0 ;
17304 PyObject * obj1 = 0 ;
17305 PyObject * obj2 = 0 ;
17306 PyObject * obj3 = 0 ;
17307 PyObject * obj4 = 0 ;
17308 char * kwnames[] = {
17309 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
17310 };
17311
17312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17314 if (!SWIG_IsOK(res1)) {
17315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
17316 }
17317 arg1 = reinterpret_cast< wxImage * >(argp1);
17318 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
17319 if (!SWIG_IsOK(res2)) {
17320 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
17321 }
17322 if (!argp2) {
17323 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
17324 }
17325 arg2 = reinterpret_cast< wxImage * >(argp2);
17326 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17327 if (!SWIG_IsOK(ecode3)) {
17328 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
17329 }
17330 arg3 = static_cast< byte >(val3);
17331 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17332 if (!SWIG_IsOK(ecode4)) {
17333 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
17334 }
17335 arg4 = static_cast< byte >(val4);
17336 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
17337 if (!SWIG_IsOK(ecode5)) {
17338 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
17339 }
17340 arg5 = static_cast< byte >(val5);
17341 {
17342 PyThreadState* __tstate = wxPyBeginAllowThreads();
17343 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
17344 wxPyEndAllowThreads(__tstate);
17345 if (PyErr_Occurred()) SWIG_fail;
17346 }
17347 {
17348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17349 }
17350 return resultobj;
17351 fail:
17352 return NULL;
17353 }
17354
17355
17356 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17357 PyObject *resultobj = 0;
17358 wxString *arg1 = 0 ;
17359 bool result;
17360 bool temp1 = false ;
17361 PyObject * obj0 = 0 ;
17362 char * kwnames[] = {
17363 (char *) "filename", NULL
17364 };
17365
17366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
17367 {
17368 arg1 = wxString_in_helper(obj0);
17369 if (arg1 == NULL) SWIG_fail;
17370 temp1 = true;
17371 }
17372 {
17373 PyThreadState* __tstate = wxPyBeginAllowThreads();
17374 result = (bool)wxImage::CanRead((wxString const &)*arg1);
17375 wxPyEndAllowThreads(__tstate);
17376 if (PyErr_Occurred()) SWIG_fail;
17377 }
17378 {
17379 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17380 }
17381 {
17382 if (temp1)
17383 delete arg1;
17384 }
17385 return resultobj;
17386 fail:
17387 {
17388 if (temp1)
17389 delete arg1;
17390 }
17391 return NULL;
17392 }
17393
17394
17395 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17396 PyObject *resultobj = 0;
17397 wxString *arg1 = 0 ;
17398 long arg2 = (long) wxBITMAP_TYPE_ANY ;
17399 int result;
17400 bool temp1 = false ;
17401 long val2 ;
17402 int ecode2 = 0 ;
17403 PyObject * obj0 = 0 ;
17404 PyObject * obj1 = 0 ;
17405 char * kwnames[] = {
17406 (char *) "filename",(char *) "type", NULL
17407 };
17408
17409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
17410 {
17411 arg1 = wxString_in_helper(obj0);
17412 if (arg1 == NULL) SWIG_fail;
17413 temp1 = true;
17414 }
17415 if (obj1) {
17416 ecode2 = SWIG_AsVal_long(obj1, &val2);
17417 if (!SWIG_IsOK(ecode2)) {
17418 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
17419 }
17420 arg2 = static_cast< long >(val2);
17421 }
17422 {
17423 PyThreadState* __tstate = wxPyBeginAllowThreads();
17424 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
17425 wxPyEndAllowThreads(__tstate);
17426 if (PyErr_Occurred()) SWIG_fail;
17427 }
17428 resultobj = SWIG_From_int(static_cast< int >(result));
17429 {
17430 if (temp1)
17431 delete arg1;
17432 }
17433 return resultobj;
17434 fail:
17435 {
17436 if (temp1)
17437 delete arg1;
17438 }
17439 return NULL;
17440 }
17441
17442
17443 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17444 PyObject *resultobj = 0;
17445 wxImage *arg1 = (wxImage *) 0 ;
17446 wxString *arg2 = 0 ;
17447 long arg3 = (long) wxBITMAP_TYPE_ANY ;
17448 int arg4 = (int) -1 ;
17449 bool result;
17450 void *argp1 = 0 ;
17451 int res1 = 0 ;
17452 bool temp2 = false ;
17453 long val3 ;
17454 int ecode3 = 0 ;
17455 int val4 ;
17456 int ecode4 = 0 ;
17457 PyObject * obj0 = 0 ;
17458 PyObject * obj1 = 0 ;
17459 PyObject * obj2 = 0 ;
17460 PyObject * obj3 = 0 ;
17461 char * kwnames[] = {
17462 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
17463 };
17464
17465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17467 if (!SWIG_IsOK(res1)) {
17468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
17469 }
17470 arg1 = reinterpret_cast< wxImage * >(argp1);
17471 {
17472 arg2 = wxString_in_helper(obj1);
17473 if (arg2 == NULL) SWIG_fail;
17474 temp2 = true;
17475 }
17476 if (obj2) {
17477 ecode3 = SWIG_AsVal_long(obj2, &val3);
17478 if (!SWIG_IsOK(ecode3)) {
17479 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
17480 }
17481 arg3 = static_cast< long >(val3);
17482 }
17483 if (obj3) {
17484 ecode4 = SWIG_AsVal_int(obj3, &val4);
17485 if (!SWIG_IsOK(ecode4)) {
17486 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
17487 }
17488 arg4 = static_cast< int >(val4);
17489 }
17490 {
17491 PyThreadState* __tstate = wxPyBeginAllowThreads();
17492 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
17493 wxPyEndAllowThreads(__tstate);
17494 if (PyErr_Occurred()) SWIG_fail;
17495 }
17496 {
17497 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17498 }
17499 {
17500 if (temp2)
17501 delete arg2;
17502 }
17503 return resultobj;
17504 fail:
17505 {
17506 if (temp2)
17507 delete arg2;
17508 }
17509 return NULL;
17510 }
17511
17512
17513 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17514 PyObject *resultobj = 0;
17515 wxImage *arg1 = (wxImage *) 0 ;
17516 wxString *arg2 = 0 ;
17517 wxString *arg3 = 0 ;
17518 int arg4 = (int) -1 ;
17519 bool result;
17520 void *argp1 = 0 ;
17521 int res1 = 0 ;
17522 bool temp2 = false ;
17523 bool temp3 = false ;
17524 int val4 ;
17525 int ecode4 = 0 ;
17526 PyObject * obj0 = 0 ;
17527 PyObject * obj1 = 0 ;
17528 PyObject * obj2 = 0 ;
17529 PyObject * obj3 = 0 ;
17530 char * kwnames[] = {
17531 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
17532 };
17533
17534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) 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_LoadMimeFile" "', 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 {
17546 arg3 = wxString_in_helper(obj2);
17547 if (arg3 == NULL) SWIG_fail;
17548 temp3 = true;
17549 }
17550 if (obj3) {
17551 ecode4 = SWIG_AsVal_int(obj3, &val4);
17552 if (!SWIG_IsOK(ecode4)) {
17553 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
17554 }
17555 arg4 = static_cast< int >(val4);
17556 }
17557 {
17558 PyThreadState* __tstate = wxPyBeginAllowThreads();
17559 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
17560 wxPyEndAllowThreads(__tstate);
17561 if (PyErr_Occurred()) SWIG_fail;
17562 }
17563 {
17564 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17565 }
17566 {
17567 if (temp2)
17568 delete arg2;
17569 }
17570 {
17571 if (temp3)
17572 delete arg3;
17573 }
17574 return resultobj;
17575 fail:
17576 {
17577 if (temp2)
17578 delete arg2;
17579 }
17580 {
17581 if (temp3)
17582 delete arg3;
17583 }
17584 return NULL;
17585 }
17586
17587
17588 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17589 PyObject *resultobj = 0;
17590 wxImage *arg1 = (wxImage *) 0 ;
17591 wxString *arg2 = 0 ;
17592 int arg3 ;
17593 bool result;
17594 void *argp1 = 0 ;
17595 int res1 = 0 ;
17596 bool temp2 = false ;
17597 int val3 ;
17598 int ecode3 = 0 ;
17599 PyObject * obj0 = 0 ;
17600 PyObject * obj1 = 0 ;
17601 PyObject * obj2 = 0 ;
17602 char * kwnames[] = {
17603 (char *) "self",(char *) "name",(char *) "type", NULL
17604 };
17605
17606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17608 if (!SWIG_IsOK(res1)) {
17609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
17610 }
17611 arg1 = reinterpret_cast< wxImage * >(argp1);
17612 {
17613 arg2 = wxString_in_helper(obj1);
17614 if (arg2 == NULL) SWIG_fail;
17615 temp2 = true;
17616 }
17617 ecode3 = SWIG_AsVal_int(obj2, &val3);
17618 if (!SWIG_IsOK(ecode3)) {
17619 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
17620 }
17621 arg3 = static_cast< int >(val3);
17622 {
17623 PyThreadState* __tstate = wxPyBeginAllowThreads();
17624 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
17625 wxPyEndAllowThreads(__tstate);
17626 if (PyErr_Occurred()) SWIG_fail;
17627 }
17628 {
17629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17630 }
17631 {
17632 if (temp2)
17633 delete arg2;
17634 }
17635 return resultobj;
17636 fail:
17637 {
17638 if (temp2)
17639 delete arg2;
17640 }
17641 return NULL;
17642 }
17643
17644
17645 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17646 PyObject *resultobj = 0;
17647 wxImage *arg1 = (wxImage *) 0 ;
17648 wxString *arg2 = 0 ;
17649 wxString *arg3 = 0 ;
17650 bool result;
17651 void *argp1 = 0 ;
17652 int res1 = 0 ;
17653 bool temp2 = false ;
17654 bool temp3 = false ;
17655 PyObject * obj0 = 0 ;
17656 PyObject * obj1 = 0 ;
17657 PyObject * obj2 = 0 ;
17658 char * kwnames[] = {
17659 (char *) "self",(char *) "name",(char *) "mimetype", NULL
17660 };
17661
17662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17664 if (!SWIG_IsOK(res1)) {
17665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
17666 }
17667 arg1 = reinterpret_cast< wxImage * >(argp1);
17668 {
17669 arg2 = wxString_in_helper(obj1);
17670 if (arg2 == NULL) SWIG_fail;
17671 temp2 = true;
17672 }
17673 {
17674 arg3 = wxString_in_helper(obj2);
17675 if (arg3 == NULL) SWIG_fail;
17676 temp3 = true;
17677 }
17678 {
17679 PyThreadState* __tstate = wxPyBeginAllowThreads();
17680 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
17681 wxPyEndAllowThreads(__tstate);
17682 if (PyErr_Occurred()) SWIG_fail;
17683 }
17684 {
17685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17686 }
17687 {
17688 if (temp2)
17689 delete arg2;
17690 }
17691 {
17692 if (temp3)
17693 delete arg3;
17694 }
17695 return resultobj;
17696 fail:
17697 {
17698 if (temp2)
17699 delete arg2;
17700 }
17701 {
17702 if (temp3)
17703 delete arg3;
17704 }
17705 return NULL;
17706 }
17707
17708
17709 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17710 PyObject *resultobj = 0;
17711 wxInputStream *arg1 = 0 ;
17712 bool result;
17713 wxPyInputStream *temp1 ;
17714 bool created1 ;
17715 PyObject * obj0 = 0 ;
17716 char * kwnames[] = {
17717 (char *) "stream", NULL
17718 };
17719
17720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
17721 {
17722 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
17723 arg1 = temp1->m_wxis;
17724 created1 = false;
17725 } else {
17726 PyErr_Clear(); // clear the failure of the wxPyConvert above
17727 arg1 = wxPyCBInputStream_create(obj0, false);
17728 if (arg1 == NULL) {
17729 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17730 SWIG_fail;
17731 }
17732 created1 = true;
17733 }
17734 }
17735 {
17736 PyThreadState* __tstate = wxPyBeginAllowThreads();
17737 result = (bool)wxImage::CanRead(*arg1);
17738 wxPyEndAllowThreads(__tstate);
17739 if (PyErr_Occurred()) SWIG_fail;
17740 }
17741 {
17742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17743 }
17744 {
17745 if (created1) delete arg1;
17746 }
17747 return resultobj;
17748 fail:
17749 {
17750 if (created1) delete arg1;
17751 }
17752 return NULL;
17753 }
17754
17755
17756 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17757 PyObject *resultobj = 0;
17758 wxImage *arg1 = (wxImage *) 0 ;
17759 wxInputStream *arg2 = 0 ;
17760 long arg3 = (long) wxBITMAP_TYPE_ANY ;
17761 int arg4 = (int) -1 ;
17762 bool result;
17763 void *argp1 = 0 ;
17764 int res1 = 0 ;
17765 wxPyInputStream *temp2 ;
17766 bool created2 ;
17767 long val3 ;
17768 int ecode3 = 0 ;
17769 int val4 ;
17770 int ecode4 = 0 ;
17771 PyObject * obj0 = 0 ;
17772 PyObject * obj1 = 0 ;
17773 PyObject * obj2 = 0 ;
17774 PyObject * obj3 = 0 ;
17775 char * kwnames[] = {
17776 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
17777 };
17778
17779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17781 if (!SWIG_IsOK(res1)) {
17782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
17783 }
17784 arg1 = reinterpret_cast< wxImage * >(argp1);
17785 {
17786 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
17787 arg2 = temp2->m_wxis;
17788 created2 = false;
17789 } else {
17790 PyErr_Clear(); // clear the failure of the wxPyConvert above
17791 arg2 = wxPyCBInputStream_create(obj1, false);
17792 if (arg2 == NULL) {
17793 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17794 SWIG_fail;
17795 }
17796 created2 = true;
17797 }
17798 }
17799 if (obj2) {
17800 ecode3 = SWIG_AsVal_long(obj2, &val3);
17801 if (!SWIG_IsOK(ecode3)) {
17802 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
17803 }
17804 arg3 = static_cast< long >(val3);
17805 }
17806 if (obj3) {
17807 ecode4 = SWIG_AsVal_int(obj3, &val4);
17808 if (!SWIG_IsOK(ecode4)) {
17809 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
17810 }
17811 arg4 = static_cast< int >(val4);
17812 }
17813 {
17814 PyThreadState* __tstate = wxPyBeginAllowThreads();
17815 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
17816 wxPyEndAllowThreads(__tstate);
17817 if (PyErr_Occurred()) SWIG_fail;
17818 }
17819 {
17820 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17821 }
17822 {
17823 if (created2) delete arg2;
17824 }
17825 return resultobj;
17826 fail:
17827 {
17828 if (created2) delete arg2;
17829 }
17830 return NULL;
17831 }
17832
17833
17834 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17835 PyObject *resultobj = 0;
17836 wxImage *arg1 = (wxImage *) 0 ;
17837 wxInputStream *arg2 = 0 ;
17838 wxString *arg3 = 0 ;
17839 int arg4 = (int) -1 ;
17840 bool result;
17841 void *argp1 = 0 ;
17842 int res1 = 0 ;
17843 wxPyInputStream *temp2 ;
17844 bool created2 ;
17845 bool temp3 = false ;
17846 int val4 ;
17847 int ecode4 = 0 ;
17848 PyObject * obj0 = 0 ;
17849 PyObject * obj1 = 0 ;
17850 PyObject * obj2 = 0 ;
17851 PyObject * obj3 = 0 ;
17852 char * kwnames[] = {
17853 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
17854 };
17855
17856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17858 if (!SWIG_IsOK(res1)) {
17859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
17860 }
17861 arg1 = reinterpret_cast< wxImage * >(argp1);
17862 {
17863 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
17864 arg2 = temp2->m_wxis;
17865 created2 = false;
17866 } else {
17867 PyErr_Clear(); // clear the failure of the wxPyConvert above
17868 arg2 = wxPyCBInputStream_create(obj1, false);
17869 if (arg2 == NULL) {
17870 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17871 SWIG_fail;
17872 }
17873 created2 = true;
17874 }
17875 }
17876 {
17877 arg3 = wxString_in_helper(obj2);
17878 if (arg3 == NULL) SWIG_fail;
17879 temp3 = true;
17880 }
17881 if (obj3) {
17882 ecode4 = SWIG_AsVal_int(obj3, &val4);
17883 if (!SWIG_IsOK(ecode4)) {
17884 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
17885 }
17886 arg4 = static_cast< int >(val4);
17887 }
17888 {
17889 PyThreadState* __tstate = wxPyBeginAllowThreads();
17890 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
17891 wxPyEndAllowThreads(__tstate);
17892 if (PyErr_Occurred()) SWIG_fail;
17893 }
17894 {
17895 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17896 }
17897 {
17898 if (created2) delete arg2;
17899 }
17900 {
17901 if (temp3)
17902 delete arg3;
17903 }
17904 return resultobj;
17905 fail:
17906 {
17907 if (created2) delete arg2;
17908 }
17909 {
17910 if (temp3)
17911 delete arg3;
17912 }
17913 return NULL;
17914 }
17915
17916
17917 SWIGINTERN PyObject *_wrap_Image_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17918 PyObject *resultobj = 0;
17919 wxImage *arg1 = (wxImage *) 0 ;
17920 bool result;
17921 void *argp1 = 0 ;
17922 int res1 = 0 ;
17923 PyObject *swig_obj[1] ;
17924
17925 if (!args) SWIG_fail;
17926 swig_obj[0] = args;
17927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17928 if (!SWIG_IsOK(res1)) {
17929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsOk" "', expected argument " "1"" of type '" "wxImage *""'");
17930 }
17931 arg1 = reinterpret_cast< wxImage * >(argp1);
17932 {
17933 PyThreadState* __tstate = wxPyBeginAllowThreads();
17934 result = (bool)(arg1)->IsOk();
17935 wxPyEndAllowThreads(__tstate);
17936 if (PyErr_Occurred()) SWIG_fail;
17937 }
17938 {
17939 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17940 }
17941 return resultobj;
17942 fail:
17943 return NULL;
17944 }
17945
17946
17947 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17948 PyObject *resultobj = 0;
17949 wxImage *arg1 = (wxImage *) 0 ;
17950 int result;
17951 void *argp1 = 0 ;
17952 int res1 = 0 ;
17953 PyObject *swig_obj[1] ;
17954
17955 if (!args) SWIG_fail;
17956 swig_obj[0] = args;
17957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17958 if (!SWIG_IsOK(res1)) {
17959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
17960 }
17961 arg1 = reinterpret_cast< wxImage * >(argp1);
17962 {
17963 PyThreadState* __tstate = wxPyBeginAllowThreads();
17964 result = (int)(arg1)->GetWidth();
17965 wxPyEndAllowThreads(__tstate);
17966 if (PyErr_Occurred()) SWIG_fail;
17967 }
17968 resultobj = SWIG_From_int(static_cast< int >(result));
17969 return resultobj;
17970 fail:
17971 return NULL;
17972 }
17973
17974
17975 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17976 PyObject *resultobj = 0;
17977 wxImage *arg1 = (wxImage *) 0 ;
17978 int result;
17979 void *argp1 = 0 ;
17980 int res1 = 0 ;
17981 PyObject *swig_obj[1] ;
17982
17983 if (!args) SWIG_fail;
17984 swig_obj[0] = args;
17985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17986 if (!SWIG_IsOK(res1)) {
17987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
17988 }
17989 arg1 = reinterpret_cast< wxImage * >(argp1);
17990 {
17991 PyThreadState* __tstate = wxPyBeginAllowThreads();
17992 result = (int)(arg1)->GetHeight();
17993 wxPyEndAllowThreads(__tstate);
17994 if (PyErr_Occurred()) SWIG_fail;
17995 }
17996 resultobj = SWIG_From_int(static_cast< int >(result));
17997 return resultobj;
17998 fail:
17999 return NULL;
18000 }
18001
18002
18003 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18004 PyObject *resultobj = 0;
18005 wxImage *arg1 = (wxImage *) 0 ;
18006 wxSize result;
18007 void *argp1 = 0 ;
18008 int res1 = 0 ;
18009 PyObject *swig_obj[1] ;
18010
18011 if (!args) SWIG_fail;
18012 swig_obj[0] = args;
18013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18014 if (!SWIG_IsOK(res1)) {
18015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
18016 }
18017 arg1 = reinterpret_cast< wxImage * >(argp1);
18018 {
18019 PyThreadState* __tstate = wxPyBeginAllowThreads();
18020 result = wxImage_GetSize(arg1);
18021 wxPyEndAllowThreads(__tstate);
18022 if (PyErr_Occurred()) SWIG_fail;
18023 }
18024 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
18025 return resultobj;
18026 fail:
18027 return NULL;
18028 }
18029
18030
18031 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18032 PyObject *resultobj = 0;
18033 wxImage *arg1 = (wxImage *) 0 ;
18034 wxRect *arg2 = 0 ;
18035 SwigValueWrapper<wxImage > result;
18036 void *argp1 = 0 ;
18037 int res1 = 0 ;
18038 wxRect temp2 ;
18039 PyObject * obj0 = 0 ;
18040 PyObject * obj1 = 0 ;
18041 char * kwnames[] = {
18042 (char *) "self",(char *) "rect", NULL
18043 };
18044
18045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
18046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18047 if (!SWIG_IsOK(res1)) {
18048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
18049 }
18050 arg1 = reinterpret_cast< wxImage * >(argp1);
18051 {
18052 arg2 = &temp2;
18053 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
18054 }
18055 {
18056 PyThreadState* __tstate = wxPyBeginAllowThreads();
18057 result = (arg1)->GetSubImage((wxRect const &)*arg2);
18058 wxPyEndAllowThreads(__tstate);
18059 if (PyErr_Occurred()) SWIG_fail;
18060 }
18061 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18062 return resultobj;
18063 fail:
18064 return NULL;
18065 }
18066
18067
18068 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18069 PyObject *resultobj = 0;
18070 wxImage *arg1 = (wxImage *) 0 ;
18071 wxSize *arg2 = 0 ;
18072 wxPoint *arg3 = 0 ;
18073 int arg4 = (int) -1 ;
18074 int arg5 = (int) -1 ;
18075 int arg6 = (int) -1 ;
18076 SwigValueWrapper<wxImage > result;
18077 void *argp1 = 0 ;
18078 int res1 = 0 ;
18079 wxSize temp2 ;
18080 wxPoint temp3 ;
18081 int val4 ;
18082 int ecode4 = 0 ;
18083 int val5 ;
18084 int ecode5 = 0 ;
18085 int val6 ;
18086 int ecode6 = 0 ;
18087 PyObject * obj0 = 0 ;
18088 PyObject * obj1 = 0 ;
18089 PyObject * obj2 = 0 ;
18090 PyObject * obj3 = 0 ;
18091 PyObject * obj4 = 0 ;
18092 PyObject * obj5 = 0 ;
18093 char * kwnames[] = {
18094 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
18095 };
18096
18097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
18098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18099 if (!SWIG_IsOK(res1)) {
18100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
18101 }
18102 arg1 = reinterpret_cast< wxImage * >(argp1);
18103 {
18104 arg2 = &temp2;
18105 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
18106 }
18107 {
18108 arg3 = &temp3;
18109 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18110 }
18111 if (obj3) {
18112 ecode4 = SWIG_AsVal_int(obj3, &val4);
18113 if (!SWIG_IsOK(ecode4)) {
18114 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
18115 }
18116 arg4 = static_cast< int >(val4);
18117 }
18118 if (obj4) {
18119 ecode5 = SWIG_AsVal_int(obj4, &val5);
18120 if (!SWIG_IsOK(ecode5)) {
18121 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
18122 }
18123 arg5 = static_cast< int >(val5);
18124 }
18125 if (obj5) {
18126 ecode6 = SWIG_AsVal_int(obj5, &val6);
18127 if (!SWIG_IsOK(ecode6)) {
18128 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
18129 }
18130 arg6 = static_cast< int >(val6);
18131 }
18132 {
18133 PyThreadState* __tstate = wxPyBeginAllowThreads();
18134 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
18135 wxPyEndAllowThreads(__tstate);
18136 if (PyErr_Occurred()) SWIG_fail;
18137 }
18138 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18139 return resultobj;
18140 fail:
18141 return NULL;
18142 }
18143
18144
18145 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18146 PyObject *resultobj = 0;
18147 wxImage *arg1 = (wxImage *) 0 ;
18148 SwigValueWrapper<wxImage > result;
18149 void *argp1 = 0 ;
18150 int res1 = 0 ;
18151 PyObject *swig_obj[1] ;
18152
18153 if (!args) SWIG_fail;
18154 swig_obj[0] = args;
18155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18156 if (!SWIG_IsOK(res1)) {
18157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
18158 }
18159 arg1 = reinterpret_cast< wxImage * >(argp1);
18160 {
18161 PyThreadState* __tstate = wxPyBeginAllowThreads();
18162 result = (arg1)->Copy();
18163 wxPyEndAllowThreads(__tstate);
18164 if (PyErr_Occurred()) SWIG_fail;
18165 }
18166 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18167 return resultobj;
18168 fail:
18169 return NULL;
18170 }
18171
18172
18173 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18174 PyObject *resultobj = 0;
18175 wxImage *arg1 = (wxImage *) 0 ;
18176 wxImage *arg2 = 0 ;
18177 int arg3 ;
18178 int arg4 ;
18179 void *argp1 = 0 ;
18180 int res1 = 0 ;
18181 void *argp2 = 0 ;
18182 int res2 = 0 ;
18183 int val3 ;
18184 int ecode3 = 0 ;
18185 int val4 ;
18186 int ecode4 = 0 ;
18187 PyObject * obj0 = 0 ;
18188 PyObject * obj1 = 0 ;
18189 PyObject * obj2 = 0 ;
18190 PyObject * obj3 = 0 ;
18191 char * kwnames[] = {
18192 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
18193 };
18194
18195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18197 if (!SWIG_IsOK(res1)) {
18198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
18199 }
18200 arg1 = reinterpret_cast< wxImage * >(argp1);
18201 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
18202 if (!SWIG_IsOK(res2)) {
18203 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
18204 }
18205 if (!argp2) {
18206 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
18207 }
18208 arg2 = reinterpret_cast< wxImage * >(argp2);
18209 ecode3 = SWIG_AsVal_int(obj2, &val3);
18210 if (!SWIG_IsOK(ecode3)) {
18211 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
18212 }
18213 arg3 = static_cast< int >(val3);
18214 ecode4 = SWIG_AsVal_int(obj3, &val4);
18215 if (!SWIG_IsOK(ecode4)) {
18216 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
18217 }
18218 arg4 = static_cast< int >(val4);
18219 {
18220 PyThreadState* __tstate = wxPyBeginAllowThreads();
18221 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
18222 wxPyEndAllowThreads(__tstate);
18223 if (PyErr_Occurred()) SWIG_fail;
18224 }
18225 resultobj = SWIG_Py_Void();
18226 return resultobj;
18227 fail:
18228 return NULL;
18229 }
18230
18231
18232 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18233 PyObject *resultobj = 0;
18234 wxImage *arg1 = (wxImage *) 0 ;
18235 PyObject *result = 0 ;
18236 void *argp1 = 0 ;
18237 int res1 = 0 ;
18238 PyObject *swig_obj[1] ;
18239
18240 if (!args) SWIG_fail;
18241 swig_obj[0] = args;
18242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18243 if (!SWIG_IsOK(res1)) {
18244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
18245 }
18246 arg1 = reinterpret_cast< wxImage * >(argp1);
18247 {
18248 PyThreadState* __tstate = wxPyBeginAllowThreads();
18249 result = (PyObject *)wxImage_GetData(arg1);
18250 wxPyEndAllowThreads(__tstate);
18251 if (PyErr_Occurred()) SWIG_fail;
18252 }
18253 resultobj = result;
18254 return resultobj;
18255 fail:
18256 return NULL;
18257 }
18258
18259
18260 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18261 PyObject *resultobj = 0;
18262 wxImage *arg1 = (wxImage *) 0 ;
18263 buffer arg2 ;
18264 int arg3 ;
18265 void *argp1 = 0 ;
18266 int res1 = 0 ;
18267 Py_ssize_t temp2 ;
18268 PyObject * obj0 = 0 ;
18269 PyObject * obj1 = 0 ;
18270 char * kwnames[] = {
18271 (char *) "self",(char *) "data", NULL
18272 };
18273
18274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
18275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18276 if (!SWIG_IsOK(res1)) {
18277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
18278 }
18279 arg1 = reinterpret_cast< wxImage * >(argp1);
18280 {
18281 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18282 arg3 = (int)temp2;
18283 }
18284 {
18285 PyThreadState* __tstate = wxPyBeginAllowThreads();
18286 wxImage_SetData(arg1,arg2,arg3);
18287 wxPyEndAllowThreads(__tstate);
18288 if (PyErr_Occurred()) SWIG_fail;
18289 }
18290 resultobj = SWIG_Py_Void();
18291 return resultobj;
18292 fail:
18293 return NULL;
18294 }
18295
18296
18297 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18298 PyObject *resultobj = 0;
18299 wxImage *arg1 = (wxImage *) 0 ;
18300 PyObject *result = 0 ;
18301 void *argp1 = 0 ;
18302 int res1 = 0 ;
18303 PyObject *swig_obj[1] ;
18304
18305 if (!args) SWIG_fail;
18306 swig_obj[0] = args;
18307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18308 if (!SWIG_IsOK(res1)) {
18309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18310 }
18311 arg1 = reinterpret_cast< wxImage * >(argp1);
18312 {
18313 PyThreadState* __tstate = wxPyBeginAllowThreads();
18314 result = (PyObject *)wxImage_GetDataBuffer(arg1);
18315 wxPyEndAllowThreads(__tstate);
18316 if (PyErr_Occurred()) SWIG_fail;
18317 }
18318 resultobj = result;
18319 return resultobj;
18320 fail:
18321 return NULL;
18322 }
18323
18324
18325 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18326 PyObject *resultobj = 0;
18327 wxImage *arg1 = (wxImage *) 0 ;
18328 buffer arg2 ;
18329 int arg3 ;
18330 void *argp1 = 0 ;
18331 int res1 = 0 ;
18332 Py_ssize_t temp2 ;
18333 PyObject * obj0 = 0 ;
18334 PyObject * obj1 = 0 ;
18335 char * kwnames[] = {
18336 (char *) "self",(char *) "data", NULL
18337 };
18338
18339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
18340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18341 if (!SWIG_IsOK(res1)) {
18342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18343 }
18344 arg1 = reinterpret_cast< wxImage * >(argp1);
18345 {
18346 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18347 arg3 = (int)temp2;
18348 }
18349 {
18350 PyThreadState* __tstate = wxPyBeginAllowThreads();
18351 wxImage_SetDataBuffer(arg1,arg2,arg3);
18352 wxPyEndAllowThreads(__tstate);
18353 if (PyErr_Occurred()) SWIG_fail;
18354 }
18355 resultobj = SWIG_Py_Void();
18356 return resultobj;
18357 fail:
18358 return NULL;
18359 }
18360
18361
18362 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18363 PyObject *resultobj = 0;
18364 wxImage *arg1 = (wxImage *) 0 ;
18365 PyObject *result = 0 ;
18366 void *argp1 = 0 ;
18367 int res1 = 0 ;
18368 PyObject *swig_obj[1] ;
18369
18370 if (!args) SWIG_fail;
18371 swig_obj[0] = args;
18372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18373 if (!SWIG_IsOK(res1)) {
18374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
18375 }
18376 arg1 = reinterpret_cast< wxImage * >(argp1);
18377 {
18378 PyThreadState* __tstate = wxPyBeginAllowThreads();
18379 result = (PyObject *)wxImage_GetAlphaData(arg1);
18380 wxPyEndAllowThreads(__tstate);
18381 if (PyErr_Occurred()) SWIG_fail;
18382 }
18383 resultobj = result;
18384 return resultobj;
18385 fail:
18386 return NULL;
18387 }
18388
18389
18390 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18391 PyObject *resultobj = 0;
18392 wxImage *arg1 = (wxImage *) 0 ;
18393 buffer arg2 ;
18394 int arg3 ;
18395 void *argp1 = 0 ;
18396 int res1 = 0 ;
18397 Py_ssize_t temp2 ;
18398 PyObject * obj0 = 0 ;
18399 PyObject * obj1 = 0 ;
18400 char * kwnames[] = {
18401 (char *) "self",(char *) "alpha", NULL
18402 };
18403
18404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
18405 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18406 if (!SWIG_IsOK(res1)) {
18407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
18408 }
18409 arg1 = reinterpret_cast< wxImage * >(argp1);
18410 {
18411 if (obj1 != Py_None) {
18412 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18413 arg3 = (int)temp2;
18414 }
18415 }
18416 {
18417 PyThreadState* __tstate = wxPyBeginAllowThreads();
18418 wxImage_SetAlphaData(arg1,arg2,arg3);
18419 wxPyEndAllowThreads(__tstate);
18420 if (PyErr_Occurred()) SWIG_fail;
18421 }
18422 resultobj = SWIG_Py_Void();
18423 return resultobj;
18424 fail:
18425 return NULL;
18426 }
18427
18428
18429 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18430 PyObject *resultobj = 0;
18431 wxImage *arg1 = (wxImage *) 0 ;
18432 PyObject *result = 0 ;
18433 void *argp1 = 0 ;
18434 int res1 = 0 ;
18435 PyObject *swig_obj[1] ;
18436
18437 if (!args) SWIG_fail;
18438 swig_obj[0] = args;
18439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18440 if (!SWIG_IsOK(res1)) {
18441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18442 }
18443 arg1 = reinterpret_cast< wxImage * >(argp1);
18444 {
18445 PyThreadState* __tstate = wxPyBeginAllowThreads();
18446 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
18447 wxPyEndAllowThreads(__tstate);
18448 if (PyErr_Occurred()) SWIG_fail;
18449 }
18450 resultobj = result;
18451 return resultobj;
18452 fail:
18453 return NULL;
18454 }
18455
18456
18457 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18458 PyObject *resultobj = 0;
18459 wxImage *arg1 = (wxImage *) 0 ;
18460 buffer arg2 ;
18461 int arg3 ;
18462 void *argp1 = 0 ;
18463 int res1 = 0 ;
18464 Py_ssize_t temp2 ;
18465 PyObject * obj0 = 0 ;
18466 PyObject * obj1 = 0 ;
18467 char * kwnames[] = {
18468 (char *) "self",(char *) "alpha", NULL
18469 };
18470
18471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
18472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18473 if (!SWIG_IsOK(res1)) {
18474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18475 }
18476 arg1 = reinterpret_cast< wxImage * >(argp1);
18477 {
18478 if (obj1 != Py_None) {
18479 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18480 arg3 = (int)temp2;
18481 }
18482 }
18483 {
18484 PyThreadState* __tstate = wxPyBeginAllowThreads();
18485 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
18486 wxPyEndAllowThreads(__tstate);
18487 if (PyErr_Occurred()) SWIG_fail;
18488 }
18489 resultobj = SWIG_Py_Void();
18490 return resultobj;
18491 fail:
18492 return NULL;
18493 }
18494
18495
18496 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18497 PyObject *resultobj = 0;
18498 wxImage *arg1 = (wxImage *) 0 ;
18499 byte arg2 ;
18500 byte arg3 ;
18501 byte arg4 ;
18502 void *argp1 = 0 ;
18503 int res1 = 0 ;
18504 unsigned char val2 ;
18505 int ecode2 = 0 ;
18506 unsigned char val3 ;
18507 int ecode3 = 0 ;
18508 unsigned char val4 ;
18509 int ecode4 = 0 ;
18510 PyObject * obj0 = 0 ;
18511 PyObject * obj1 = 0 ;
18512 PyObject * obj2 = 0 ;
18513 PyObject * obj3 = 0 ;
18514 char * kwnames[] = {
18515 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
18516 };
18517
18518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18520 if (!SWIG_IsOK(res1)) {
18521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
18522 }
18523 arg1 = reinterpret_cast< wxImage * >(argp1);
18524 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
18525 if (!SWIG_IsOK(ecode2)) {
18526 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
18527 }
18528 arg2 = static_cast< byte >(val2);
18529 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
18530 if (!SWIG_IsOK(ecode3)) {
18531 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
18532 }
18533 arg3 = static_cast< byte >(val3);
18534 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
18535 if (!SWIG_IsOK(ecode4)) {
18536 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
18537 }
18538 arg4 = static_cast< byte >(val4);
18539 {
18540 PyThreadState* __tstate = wxPyBeginAllowThreads();
18541 (arg1)->SetMaskColour(arg2,arg3,arg4);
18542 wxPyEndAllowThreads(__tstate);
18543 if (PyErr_Occurred()) SWIG_fail;
18544 }
18545 resultobj = SWIG_Py_Void();
18546 return resultobj;
18547 fail:
18548 return NULL;
18549 }
18550
18551
18552 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18553 PyObject *resultobj = 0;
18554 wxImage *arg1 = (wxImage *) 0 ;
18555 byte *arg2 = (byte *) 0 ;
18556 byte *arg3 = (byte *) 0 ;
18557 byte *arg4 = (byte *) 0 ;
18558 void *argp1 = 0 ;
18559 int res1 = 0 ;
18560 byte temp2 ;
18561 int res2 = SWIG_TMPOBJ ;
18562 byte temp3 ;
18563 int res3 = SWIG_TMPOBJ ;
18564 byte temp4 ;
18565 int res4 = SWIG_TMPOBJ ;
18566 PyObject *swig_obj[1] ;
18567
18568 arg2 = &temp2;
18569 arg3 = &temp3;
18570 arg4 = &temp4;
18571 if (!args) SWIG_fail;
18572 swig_obj[0] = args;
18573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18574 if (!SWIG_IsOK(res1)) {
18575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
18576 }
18577 arg1 = reinterpret_cast< wxImage * >(argp1);
18578 {
18579 PyThreadState* __tstate = wxPyBeginAllowThreads();
18580 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
18581 wxPyEndAllowThreads(__tstate);
18582 if (PyErr_Occurred()) SWIG_fail;
18583 }
18584 resultobj = SWIG_Py_Void();
18585 if (SWIG_IsTmpObj(res2)) {
18586 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
18587 } else {
18588 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18589 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
18590 }
18591 if (SWIG_IsTmpObj(res3)) {
18592 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
18593 } else {
18594 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18595 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
18596 }
18597 if (SWIG_IsTmpObj(res4)) {
18598 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
18599 } else {
18600 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18601 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
18602 }
18603 return resultobj;
18604 fail:
18605 return NULL;
18606 }
18607
18608
18609 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18610 PyObject *resultobj = 0;
18611 wxImage *arg1 = (wxImage *) 0 ;
18612 byte result;
18613 void *argp1 = 0 ;
18614 int res1 = 0 ;
18615 PyObject *swig_obj[1] ;
18616
18617 if (!args) SWIG_fail;
18618 swig_obj[0] = args;
18619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18620 if (!SWIG_IsOK(res1)) {
18621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
18622 }
18623 arg1 = reinterpret_cast< wxImage * >(argp1);
18624 {
18625 PyThreadState* __tstate = wxPyBeginAllowThreads();
18626 result = (byte)(arg1)->GetMaskRed();
18627 wxPyEndAllowThreads(__tstate);
18628 if (PyErr_Occurred()) SWIG_fail;
18629 }
18630 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18631 return resultobj;
18632 fail:
18633 return NULL;
18634 }
18635
18636
18637 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18638 PyObject *resultobj = 0;
18639 wxImage *arg1 = (wxImage *) 0 ;
18640 byte result;
18641 void *argp1 = 0 ;
18642 int res1 = 0 ;
18643 PyObject *swig_obj[1] ;
18644
18645 if (!args) SWIG_fail;
18646 swig_obj[0] = args;
18647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18648 if (!SWIG_IsOK(res1)) {
18649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
18650 }
18651 arg1 = reinterpret_cast< wxImage * >(argp1);
18652 {
18653 PyThreadState* __tstate = wxPyBeginAllowThreads();
18654 result = (byte)(arg1)->GetMaskGreen();
18655 wxPyEndAllowThreads(__tstate);
18656 if (PyErr_Occurred()) SWIG_fail;
18657 }
18658 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18659 return resultobj;
18660 fail:
18661 return NULL;
18662 }
18663
18664
18665 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18666 PyObject *resultobj = 0;
18667 wxImage *arg1 = (wxImage *) 0 ;
18668 byte result;
18669 void *argp1 = 0 ;
18670 int res1 = 0 ;
18671 PyObject *swig_obj[1] ;
18672
18673 if (!args) SWIG_fail;
18674 swig_obj[0] = args;
18675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18676 if (!SWIG_IsOK(res1)) {
18677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
18678 }
18679 arg1 = reinterpret_cast< wxImage * >(argp1);
18680 {
18681 PyThreadState* __tstate = wxPyBeginAllowThreads();
18682 result = (byte)(arg1)->GetMaskBlue();
18683 wxPyEndAllowThreads(__tstate);
18684 if (PyErr_Occurred()) SWIG_fail;
18685 }
18686 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18687 return resultobj;
18688 fail:
18689 return NULL;
18690 }
18691
18692
18693 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18694 PyObject *resultobj = 0;
18695 wxImage *arg1 = (wxImage *) 0 ;
18696 bool arg2 = (bool) true ;
18697 void *argp1 = 0 ;
18698 int res1 = 0 ;
18699 bool val2 ;
18700 int ecode2 = 0 ;
18701 PyObject * obj0 = 0 ;
18702 PyObject * obj1 = 0 ;
18703 char * kwnames[] = {
18704 (char *) "self",(char *) "mask", NULL
18705 };
18706
18707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
18708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18709 if (!SWIG_IsOK(res1)) {
18710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
18711 }
18712 arg1 = reinterpret_cast< wxImage * >(argp1);
18713 if (obj1) {
18714 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18715 if (!SWIG_IsOK(ecode2)) {
18716 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
18717 }
18718 arg2 = static_cast< bool >(val2);
18719 }
18720 {
18721 PyThreadState* __tstate = wxPyBeginAllowThreads();
18722 (arg1)->SetMask(arg2);
18723 wxPyEndAllowThreads(__tstate);
18724 if (PyErr_Occurred()) SWIG_fail;
18725 }
18726 resultobj = SWIG_Py_Void();
18727 return resultobj;
18728 fail:
18729 return NULL;
18730 }
18731
18732
18733 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18734 PyObject *resultobj = 0;
18735 wxImage *arg1 = (wxImage *) 0 ;
18736 bool result;
18737 void *argp1 = 0 ;
18738 int res1 = 0 ;
18739 PyObject *swig_obj[1] ;
18740
18741 if (!args) SWIG_fail;
18742 swig_obj[0] = args;
18743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18744 if (!SWIG_IsOK(res1)) {
18745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
18746 }
18747 arg1 = reinterpret_cast< wxImage * >(argp1);
18748 {
18749 PyThreadState* __tstate = wxPyBeginAllowThreads();
18750 result = (bool)(arg1)->HasMask();
18751 wxPyEndAllowThreads(__tstate);
18752 if (PyErr_Occurred()) SWIG_fail;
18753 }
18754 {
18755 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18756 }
18757 return resultobj;
18758 fail:
18759 return NULL;
18760 }
18761
18762
18763 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18764 PyObject *resultobj = 0;
18765 wxImage *arg1 = (wxImage *) 0 ;
18766 double arg2 ;
18767 wxPoint *arg3 = 0 ;
18768 bool arg4 = (bool) true ;
18769 wxPoint *arg5 = (wxPoint *) NULL ;
18770 SwigValueWrapper<wxImage > result;
18771 void *argp1 = 0 ;
18772 int res1 = 0 ;
18773 double val2 ;
18774 int ecode2 = 0 ;
18775 wxPoint temp3 ;
18776 bool val4 ;
18777 int ecode4 = 0 ;
18778 void *argp5 = 0 ;
18779 int res5 = 0 ;
18780 PyObject * obj0 = 0 ;
18781 PyObject * obj1 = 0 ;
18782 PyObject * obj2 = 0 ;
18783 PyObject * obj3 = 0 ;
18784 PyObject * obj4 = 0 ;
18785 char * kwnames[] = {
18786 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
18787 };
18788
18789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18791 if (!SWIG_IsOK(res1)) {
18792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
18793 }
18794 arg1 = reinterpret_cast< wxImage * >(argp1);
18795 ecode2 = SWIG_AsVal_double(obj1, &val2);
18796 if (!SWIG_IsOK(ecode2)) {
18797 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
18798 }
18799 arg2 = static_cast< double >(val2);
18800 {
18801 arg3 = &temp3;
18802 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18803 }
18804 if (obj3) {
18805 ecode4 = SWIG_AsVal_bool(obj3, &val4);
18806 if (!SWIG_IsOK(ecode4)) {
18807 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
18808 }
18809 arg4 = static_cast< bool >(val4);
18810 }
18811 if (obj4) {
18812 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
18813 if (!SWIG_IsOK(res5)) {
18814 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
18815 }
18816 arg5 = reinterpret_cast< wxPoint * >(argp5);
18817 }
18818 {
18819 PyThreadState* __tstate = wxPyBeginAllowThreads();
18820 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
18821 wxPyEndAllowThreads(__tstate);
18822 if (PyErr_Occurred()) SWIG_fail;
18823 }
18824 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18825 return resultobj;
18826 fail:
18827 return NULL;
18828 }
18829
18830
18831 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18832 PyObject *resultobj = 0;
18833 wxImage *arg1 = (wxImage *) 0 ;
18834 bool arg2 = (bool) true ;
18835 SwigValueWrapper<wxImage > result;
18836 void *argp1 = 0 ;
18837 int res1 = 0 ;
18838 bool val2 ;
18839 int ecode2 = 0 ;
18840 PyObject * obj0 = 0 ;
18841 PyObject * obj1 = 0 ;
18842 char * kwnames[] = {
18843 (char *) "self",(char *) "clockwise", NULL
18844 };
18845
18846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
18847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18848 if (!SWIG_IsOK(res1)) {
18849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
18850 }
18851 arg1 = reinterpret_cast< wxImage * >(argp1);
18852 if (obj1) {
18853 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18854 if (!SWIG_IsOK(ecode2)) {
18855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
18856 }
18857 arg2 = static_cast< bool >(val2);
18858 }
18859 {
18860 PyThreadState* __tstate = wxPyBeginAllowThreads();
18861 result = (arg1)->Rotate90(arg2);
18862 wxPyEndAllowThreads(__tstate);
18863 if (PyErr_Occurred()) SWIG_fail;
18864 }
18865 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18866 return resultobj;
18867 fail:
18868 return NULL;
18869 }
18870
18871
18872 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18873 PyObject *resultobj = 0;
18874 wxImage *arg1 = (wxImage *) 0 ;
18875 bool arg2 = (bool) true ;
18876 SwigValueWrapper<wxImage > result;
18877 void *argp1 = 0 ;
18878 int res1 = 0 ;
18879 bool val2 ;
18880 int ecode2 = 0 ;
18881 PyObject * obj0 = 0 ;
18882 PyObject * obj1 = 0 ;
18883 char * kwnames[] = {
18884 (char *) "self",(char *) "horizontally", NULL
18885 };
18886
18887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
18888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18889 if (!SWIG_IsOK(res1)) {
18890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
18891 }
18892 arg1 = reinterpret_cast< wxImage * >(argp1);
18893 if (obj1) {
18894 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18895 if (!SWIG_IsOK(ecode2)) {
18896 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
18897 }
18898 arg2 = static_cast< bool >(val2);
18899 }
18900 {
18901 PyThreadState* __tstate = wxPyBeginAllowThreads();
18902 result = (arg1)->Mirror(arg2);
18903 wxPyEndAllowThreads(__tstate);
18904 if (PyErr_Occurred()) SWIG_fail;
18905 }
18906 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18907 return resultobj;
18908 fail:
18909 return NULL;
18910 }
18911
18912
18913 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18914 PyObject *resultobj = 0;
18915 wxImage *arg1 = (wxImage *) 0 ;
18916 byte arg2 ;
18917 byte arg3 ;
18918 byte arg4 ;
18919 byte arg5 ;
18920 byte arg6 ;
18921 byte arg7 ;
18922 void *argp1 = 0 ;
18923 int res1 = 0 ;
18924 unsigned char val2 ;
18925 int ecode2 = 0 ;
18926 unsigned char val3 ;
18927 int ecode3 = 0 ;
18928 unsigned char val4 ;
18929 int ecode4 = 0 ;
18930 unsigned char val5 ;
18931 int ecode5 = 0 ;
18932 unsigned char val6 ;
18933 int ecode6 = 0 ;
18934 unsigned char val7 ;
18935 int ecode7 = 0 ;
18936 PyObject * obj0 = 0 ;
18937 PyObject * obj1 = 0 ;
18938 PyObject * obj2 = 0 ;
18939 PyObject * obj3 = 0 ;
18940 PyObject * obj4 = 0 ;
18941 PyObject * obj5 = 0 ;
18942 PyObject * obj6 = 0 ;
18943 char * kwnames[] = {
18944 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
18945 };
18946
18947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) 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_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
18951 }
18952 arg1 = reinterpret_cast< wxImage * >(argp1);
18953 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
18954 if (!SWIG_IsOK(ecode2)) {
18955 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
18956 }
18957 arg2 = static_cast< byte >(val2);
18958 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
18959 if (!SWIG_IsOK(ecode3)) {
18960 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
18961 }
18962 arg3 = static_cast< byte >(val3);
18963 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
18964 if (!SWIG_IsOK(ecode4)) {
18965 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
18966 }
18967 arg4 = static_cast< byte >(val4);
18968 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
18969 if (!SWIG_IsOK(ecode5)) {
18970 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
18971 }
18972 arg5 = static_cast< byte >(val5);
18973 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
18974 if (!SWIG_IsOK(ecode6)) {
18975 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
18976 }
18977 arg6 = static_cast< byte >(val6);
18978 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
18979 if (!SWIG_IsOK(ecode7)) {
18980 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
18981 }
18982 arg7 = static_cast< byte >(val7);
18983 {
18984 PyThreadState* __tstate = wxPyBeginAllowThreads();
18985 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
18986 wxPyEndAllowThreads(__tstate);
18987 if (PyErr_Occurred()) SWIG_fail;
18988 }
18989 resultobj = SWIG_Py_Void();
18990 return resultobj;
18991 fail:
18992 return NULL;
18993 }
18994
18995
18996 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18997 PyObject *resultobj = 0;
18998 wxImage *arg1 = (wxImage *) 0 ;
18999 double arg2 = (double) 0.299 ;
19000 double arg3 = (double) 0.587 ;
19001 double arg4 = (double) 0.114 ;
19002 SwigValueWrapper<wxImage > result;
19003 void *argp1 = 0 ;
19004 int res1 = 0 ;
19005 double val2 ;
19006 int ecode2 = 0 ;
19007 double val3 ;
19008 int ecode3 = 0 ;
19009 double val4 ;
19010 int ecode4 = 0 ;
19011 PyObject * obj0 = 0 ;
19012 PyObject * obj1 = 0 ;
19013 PyObject * obj2 = 0 ;
19014 PyObject * obj3 = 0 ;
19015 char * kwnames[] = {
19016 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
19017 };
19018
19019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19021 if (!SWIG_IsOK(res1)) {
19022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
19023 }
19024 arg1 = reinterpret_cast< wxImage * >(argp1);
19025 if (obj1) {
19026 ecode2 = SWIG_AsVal_double(obj1, &val2);
19027 if (!SWIG_IsOK(ecode2)) {
19028 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
19029 }
19030 arg2 = static_cast< double >(val2);
19031 }
19032 if (obj2) {
19033 ecode3 = SWIG_AsVal_double(obj2, &val3);
19034 if (!SWIG_IsOK(ecode3)) {
19035 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
19036 }
19037 arg3 = static_cast< double >(val3);
19038 }
19039 if (obj3) {
19040 ecode4 = SWIG_AsVal_double(obj3, &val4);
19041 if (!SWIG_IsOK(ecode4)) {
19042 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
19043 }
19044 arg4 = static_cast< double >(val4);
19045 }
19046 {
19047 PyThreadState* __tstate = wxPyBeginAllowThreads();
19048 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
19049 wxPyEndAllowThreads(__tstate);
19050 if (PyErr_Occurred()) SWIG_fail;
19051 }
19052 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
19053 return resultobj;
19054 fail:
19055 return NULL;
19056 }
19057
19058
19059 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19060 PyObject *resultobj = 0;
19061 wxImage *arg1 = (wxImage *) 0 ;
19062 byte arg2 ;
19063 byte arg3 ;
19064 byte arg4 ;
19065 SwigValueWrapper<wxImage > result;
19066 void *argp1 = 0 ;
19067 int res1 = 0 ;
19068 unsigned char val2 ;
19069 int ecode2 = 0 ;
19070 unsigned char val3 ;
19071 int ecode3 = 0 ;
19072 unsigned char val4 ;
19073 int ecode4 = 0 ;
19074 PyObject * obj0 = 0 ;
19075 PyObject * obj1 = 0 ;
19076 PyObject * obj2 = 0 ;
19077 PyObject * obj3 = 0 ;
19078 char * kwnames[] = {
19079 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
19080 };
19081
19082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19084 if (!SWIG_IsOK(res1)) {
19085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
19086 }
19087 arg1 = reinterpret_cast< wxImage * >(argp1);
19088 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
19089 if (!SWIG_IsOK(ecode2)) {
19090 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
19091 }
19092 arg2 = static_cast< byte >(val2);
19093 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
19094 if (!SWIG_IsOK(ecode3)) {
19095 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
19096 }
19097 arg3 = static_cast< byte >(val3);
19098 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
19099 if (!SWIG_IsOK(ecode4)) {
19100 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
19101 }
19102 arg4 = static_cast< byte >(val4);
19103 {
19104 PyThreadState* __tstate = wxPyBeginAllowThreads();
19105 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
19106 wxPyEndAllowThreads(__tstate);
19107 if (PyErr_Occurred()) SWIG_fail;
19108 }
19109 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
19110 return resultobj;
19111 fail:
19112 return NULL;
19113 }
19114
19115
19116 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19117 PyObject *resultobj = 0;
19118 wxImage *arg1 = (wxImage *) 0 ;
19119 wxString *arg2 = 0 ;
19120 wxString *arg3 = 0 ;
19121 void *argp1 = 0 ;
19122 int res1 = 0 ;
19123 bool temp2 = false ;
19124 bool temp3 = false ;
19125 PyObject * obj0 = 0 ;
19126 PyObject * obj1 = 0 ;
19127 PyObject * obj2 = 0 ;
19128 char * kwnames[] = {
19129 (char *) "self",(char *) "name",(char *) "value", NULL
19130 };
19131
19132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19134 if (!SWIG_IsOK(res1)) {
19135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
19136 }
19137 arg1 = reinterpret_cast< wxImage * >(argp1);
19138 {
19139 arg2 = wxString_in_helper(obj1);
19140 if (arg2 == NULL) SWIG_fail;
19141 temp2 = true;
19142 }
19143 {
19144 arg3 = wxString_in_helper(obj2);
19145 if (arg3 == NULL) SWIG_fail;
19146 temp3 = true;
19147 }
19148 {
19149 PyThreadState* __tstate = wxPyBeginAllowThreads();
19150 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
19151 wxPyEndAllowThreads(__tstate);
19152 if (PyErr_Occurred()) SWIG_fail;
19153 }
19154 resultobj = SWIG_Py_Void();
19155 {
19156 if (temp2)
19157 delete arg2;
19158 }
19159 {
19160 if (temp3)
19161 delete arg3;
19162 }
19163 return resultobj;
19164 fail:
19165 {
19166 if (temp2)
19167 delete arg2;
19168 }
19169 {
19170 if (temp3)
19171 delete arg3;
19172 }
19173 return NULL;
19174 }
19175
19176
19177 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19178 PyObject *resultobj = 0;
19179 wxImage *arg1 = (wxImage *) 0 ;
19180 wxString *arg2 = 0 ;
19181 int arg3 ;
19182 void *argp1 = 0 ;
19183 int res1 = 0 ;
19184 bool temp2 = false ;
19185 int val3 ;
19186 int ecode3 = 0 ;
19187 PyObject * obj0 = 0 ;
19188 PyObject * obj1 = 0 ;
19189 PyObject * obj2 = 0 ;
19190 char * kwnames[] = {
19191 (char *) "self",(char *) "name",(char *) "value", NULL
19192 };
19193
19194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19196 if (!SWIG_IsOK(res1)) {
19197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
19198 }
19199 arg1 = reinterpret_cast< wxImage * >(argp1);
19200 {
19201 arg2 = wxString_in_helper(obj1);
19202 if (arg2 == NULL) SWIG_fail;
19203 temp2 = true;
19204 }
19205 ecode3 = SWIG_AsVal_int(obj2, &val3);
19206 if (!SWIG_IsOK(ecode3)) {
19207 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
19208 }
19209 arg3 = static_cast< int >(val3);
19210 {
19211 PyThreadState* __tstate = wxPyBeginAllowThreads();
19212 (arg1)->SetOption((wxString const &)*arg2,arg3);
19213 wxPyEndAllowThreads(__tstate);
19214 if (PyErr_Occurred()) SWIG_fail;
19215 }
19216 resultobj = SWIG_Py_Void();
19217 {
19218 if (temp2)
19219 delete arg2;
19220 }
19221 return resultobj;
19222 fail:
19223 {
19224 if (temp2)
19225 delete arg2;
19226 }
19227 return NULL;
19228 }
19229
19230
19231 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19232 PyObject *resultobj = 0;
19233 wxImage *arg1 = (wxImage *) 0 ;
19234 wxString *arg2 = 0 ;
19235 wxString result;
19236 void *argp1 = 0 ;
19237 int res1 = 0 ;
19238 bool temp2 = false ;
19239 PyObject * obj0 = 0 ;
19240 PyObject * obj1 = 0 ;
19241 char * kwnames[] = {
19242 (char *) "self",(char *) "name", NULL
19243 };
19244
19245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
19246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19247 if (!SWIG_IsOK(res1)) {
19248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
19249 }
19250 arg1 = reinterpret_cast< wxImage * >(argp1);
19251 {
19252 arg2 = wxString_in_helper(obj1);
19253 if (arg2 == NULL) SWIG_fail;
19254 temp2 = true;
19255 }
19256 {
19257 PyThreadState* __tstate = wxPyBeginAllowThreads();
19258 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
19259 wxPyEndAllowThreads(__tstate);
19260 if (PyErr_Occurred()) SWIG_fail;
19261 }
19262 {
19263 #if wxUSE_UNICODE
19264 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19265 #else
19266 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19267 #endif
19268 }
19269 {
19270 if (temp2)
19271 delete arg2;
19272 }
19273 return resultobj;
19274 fail:
19275 {
19276 if (temp2)
19277 delete arg2;
19278 }
19279 return NULL;
19280 }
19281
19282
19283 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19284 PyObject *resultobj = 0;
19285 wxImage *arg1 = (wxImage *) 0 ;
19286 wxString *arg2 = 0 ;
19287 int result;
19288 void *argp1 = 0 ;
19289 int res1 = 0 ;
19290 bool temp2 = false ;
19291 PyObject * obj0 = 0 ;
19292 PyObject * obj1 = 0 ;
19293 char * kwnames[] = {
19294 (char *) "self",(char *) "name", NULL
19295 };
19296
19297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
19298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19299 if (!SWIG_IsOK(res1)) {
19300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
19301 }
19302 arg1 = reinterpret_cast< wxImage * >(argp1);
19303 {
19304 arg2 = wxString_in_helper(obj1);
19305 if (arg2 == NULL) SWIG_fail;
19306 temp2 = true;
19307 }
19308 {
19309 PyThreadState* __tstate = wxPyBeginAllowThreads();
19310 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
19311 wxPyEndAllowThreads(__tstate);
19312 if (PyErr_Occurred()) SWIG_fail;
19313 }
19314 resultobj = SWIG_From_int(static_cast< int >(result));
19315 {
19316 if (temp2)
19317 delete arg2;
19318 }
19319 return resultobj;
19320 fail:
19321 {
19322 if (temp2)
19323 delete arg2;
19324 }
19325 return NULL;
19326 }
19327
19328
19329 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19330 PyObject *resultobj = 0;
19331 wxImage *arg1 = (wxImage *) 0 ;
19332 wxString *arg2 = 0 ;
19333 bool result;
19334 void *argp1 = 0 ;
19335 int res1 = 0 ;
19336 bool temp2 = false ;
19337 PyObject * obj0 = 0 ;
19338 PyObject * obj1 = 0 ;
19339 char * kwnames[] = {
19340 (char *) "self",(char *) "name", NULL
19341 };
19342
19343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
19344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19345 if (!SWIG_IsOK(res1)) {
19346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
19347 }
19348 arg1 = reinterpret_cast< wxImage * >(argp1);
19349 {
19350 arg2 = wxString_in_helper(obj1);
19351 if (arg2 == NULL) SWIG_fail;
19352 temp2 = true;
19353 }
19354 {
19355 PyThreadState* __tstate = wxPyBeginAllowThreads();
19356 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
19357 wxPyEndAllowThreads(__tstate);
19358 if (PyErr_Occurred()) SWIG_fail;
19359 }
19360 {
19361 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19362 }
19363 {
19364 if (temp2)
19365 delete arg2;
19366 }
19367 return resultobj;
19368 fail:
19369 {
19370 if (temp2)
19371 delete arg2;
19372 }
19373 return NULL;
19374 }
19375
19376
19377 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19378 PyObject *resultobj = 0;
19379 wxImage *arg1 = (wxImage *) 0 ;
19380 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
19381 unsigned long result;
19382 void *argp1 = 0 ;
19383 int res1 = 0 ;
19384 unsigned long val2 ;
19385 int ecode2 = 0 ;
19386 PyObject * obj0 = 0 ;
19387 PyObject * obj1 = 0 ;
19388 char * kwnames[] = {
19389 (char *) "self",(char *) "stopafter", NULL
19390 };
19391
19392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
19393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19394 if (!SWIG_IsOK(res1)) {
19395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
19396 }
19397 arg1 = reinterpret_cast< wxImage * >(argp1);
19398 if (obj1) {
19399 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
19400 if (!SWIG_IsOK(ecode2)) {
19401 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
19402 }
19403 arg2 = static_cast< unsigned long >(val2);
19404 }
19405 {
19406 PyThreadState* __tstate = wxPyBeginAllowThreads();
19407 result = (unsigned long)(arg1)->CountColours(arg2);
19408 wxPyEndAllowThreads(__tstate);
19409 if (PyErr_Occurred()) SWIG_fail;
19410 }
19411 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
19412 return resultobj;
19413 fail:
19414 return NULL;
19415 }
19416
19417
19418 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19419 PyObject *resultobj = 0;
19420 wxImage *arg1 = (wxImage *) 0 ;
19421 wxImageHistogram *arg2 = 0 ;
19422 unsigned long result;
19423 void *argp1 = 0 ;
19424 int res1 = 0 ;
19425 void *argp2 = 0 ;
19426 int res2 = 0 ;
19427 PyObject * obj0 = 0 ;
19428 PyObject * obj1 = 0 ;
19429 char * kwnames[] = {
19430 (char *) "self",(char *) "h", NULL
19431 };
19432
19433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
19434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19435 if (!SWIG_IsOK(res1)) {
19436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
19437 }
19438 arg1 = reinterpret_cast< wxImage * >(argp1);
19439 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
19440 if (!SWIG_IsOK(res2)) {
19441 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
19442 }
19443 if (!argp2) {
19444 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
19445 }
19446 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
19447 {
19448 PyThreadState* __tstate = wxPyBeginAllowThreads();
19449 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
19450 wxPyEndAllowThreads(__tstate);
19451 if (PyErr_Occurred()) SWIG_fail;
19452 }
19453 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
19454 return resultobj;
19455 fail:
19456 return NULL;
19457 }
19458
19459
19460 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19461 PyObject *resultobj = 0;
19462 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
19463 void *argp1 = 0 ;
19464 int res1 = 0 ;
19465 PyObject * obj0 = 0 ;
19466 char * kwnames[] = {
19467 (char *) "handler", NULL
19468 };
19469
19470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
19471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
19472 if (!SWIG_IsOK(res1)) {
19473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
19474 }
19475 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
19476 {
19477 PyThreadState* __tstate = wxPyBeginAllowThreads();
19478 wxImage::AddHandler(arg1);
19479 wxPyEndAllowThreads(__tstate);
19480 if (PyErr_Occurred()) SWIG_fail;
19481 }
19482 resultobj = SWIG_Py_Void();
19483 return resultobj;
19484 fail:
19485 return NULL;
19486 }
19487
19488
19489 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19490 PyObject *resultobj = 0;
19491 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
19492 void *argp1 = 0 ;
19493 int res1 = 0 ;
19494 PyObject * obj0 = 0 ;
19495 char * kwnames[] = {
19496 (char *) "handler", NULL
19497 };
19498
19499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
19500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
19501 if (!SWIG_IsOK(res1)) {
19502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
19503 }
19504 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
19505 {
19506 PyThreadState* __tstate = wxPyBeginAllowThreads();
19507 wxImage::InsertHandler(arg1);
19508 wxPyEndAllowThreads(__tstate);
19509 if (PyErr_Occurred()) SWIG_fail;
19510 }
19511 resultobj = SWIG_Py_Void();
19512 return resultobj;
19513 fail:
19514 return NULL;
19515 }
19516
19517
19518 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19519 PyObject *resultobj = 0;
19520 wxString *arg1 = 0 ;
19521 bool result;
19522 bool temp1 = false ;
19523 PyObject * obj0 = 0 ;
19524 char * kwnames[] = {
19525 (char *) "name", NULL
19526 };
19527
19528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
19529 {
19530 arg1 = wxString_in_helper(obj0);
19531 if (arg1 == NULL) SWIG_fail;
19532 temp1 = true;
19533 }
19534 {
19535 PyThreadState* __tstate = wxPyBeginAllowThreads();
19536 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
19537 wxPyEndAllowThreads(__tstate);
19538 if (PyErr_Occurred()) SWIG_fail;
19539 }
19540 {
19541 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19542 }
19543 {
19544 if (temp1)
19545 delete arg1;
19546 }
19547 return resultobj;
19548 fail:
19549 {
19550 if (temp1)
19551 delete arg1;
19552 }
19553 return NULL;
19554 }
19555
19556
19557 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19558 PyObject *resultobj = 0;
19559 PyObject *result = 0 ;
19560
19561 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
19562 {
19563 PyThreadState* __tstate = wxPyBeginAllowThreads();
19564 result = (PyObject *)wxImage_GetHandlers();
19565 wxPyEndAllowThreads(__tstate);
19566 if (PyErr_Occurred()) SWIG_fail;
19567 }
19568 resultobj = result;
19569 return resultobj;
19570 fail:
19571 return NULL;
19572 }
19573
19574
19575 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19576 PyObject *resultobj = 0;
19577 wxString result;
19578
19579 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
19580 {
19581 PyThreadState* __tstate = wxPyBeginAllowThreads();
19582 result = wxImage::GetImageExtWildcard();
19583 wxPyEndAllowThreads(__tstate);
19584 if (PyErr_Occurred()) SWIG_fail;
19585 }
19586 {
19587 #if wxUSE_UNICODE
19588 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19589 #else
19590 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19591 #endif
19592 }
19593 return resultobj;
19594 fail:
19595 return NULL;
19596 }
19597
19598
19599 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19600 PyObject *resultobj = 0;
19601 wxImage *arg1 = (wxImage *) 0 ;
19602 int arg2 = (int) -1 ;
19603 wxBitmap result;
19604 void *argp1 = 0 ;
19605 int res1 = 0 ;
19606 int val2 ;
19607 int ecode2 = 0 ;
19608 PyObject * obj0 = 0 ;
19609 PyObject * obj1 = 0 ;
19610 char * kwnames[] = {
19611 (char *) "self",(char *) "depth", NULL
19612 };
19613
19614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
19615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19616 if (!SWIG_IsOK(res1)) {
19617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
19618 }
19619 arg1 = reinterpret_cast< wxImage * >(argp1);
19620 if (obj1) {
19621 ecode2 = SWIG_AsVal_int(obj1, &val2);
19622 if (!SWIG_IsOK(ecode2)) {
19623 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
19624 }
19625 arg2 = static_cast< int >(val2);
19626 }
19627 {
19628 if (!wxPyCheckForApp()) SWIG_fail;
19629 PyThreadState* __tstate = wxPyBeginAllowThreads();
19630 result = wxImage_ConvertToBitmap(arg1,arg2);
19631 wxPyEndAllowThreads(__tstate);
19632 if (PyErr_Occurred()) SWIG_fail;
19633 }
19634 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19635 return resultobj;
19636 fail:
19637 return NULL;
19638 }
19639
19640
19641 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19642 PyObject *resultobj = 0;
19643 wxImage *arg1 = (wxImage *) 0 ;
19644 byte arg2 ;
19645 byte arg3 ;
19646 byte arg4 ;
19647 wxBitmap result;
19648 void *argp1 = 0 ;
19649 int res1 = 0 ;
19650 unsigned char val2 ;
19651 int ecode2 = 0 ;
19652 unsigned char val3 ;
19653 int ecode3 = 0 ;
19654 unsigned char val4 ;
19655 int ecode4 = 0 ;
19656 PyObject * obj0 = 0 ;
19657 PyObject * obj1 = 0 ;
19658 PyObject * obj2 = 0 ;
19659 PyObject * obj3 = 0 ;
19660 char * kwnames[] = {
19661 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
19662 };
19663
19664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19666 if (!SWIG_IsOK(res1)) {
19667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
19668 }
19669 arg1 = reinterpret_cast< wxImage * >(argp1);
19670 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
19671 if (!SWIG_IsOK(ecode2)) {
19672 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
19673 }
19674 arg2 = static_cast< byte >(val2);
19675 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
19676 if (!SWIG_IsOK(ecode3)) {
19677 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
19678 }
19679 arg3 = static_cast< byte >(val3);
19680 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
19681 if (!SWIG_IsOK(ecode4)) {
19682 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
19683 }
19684 arg4 = static_cast< byte >(val4);
19685 {
19686 if (!wxPyCheckForApp()) SWIG_fail;
19687 PyThreadState* __tstate = wxPyBeginAllowThreads();
19688 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
19689 wxPyEndAllowThreads(__tstate);
19690 if (PyErr_Occurred()) SWIG_fail;
19691 }
19692 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19693 return resultobj;
19694 fail:
19695 return NULL;
19696 }
19697
19698
19699 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19700 PyObject *resultobj = 0;
19701 wxImage *arg1 = (wxImage *) 0 ;
19702 double arg2 ;
19703 void *argp1 = 0 ;
19704 int res1 = 0 ;
19705 double val2 ;
19706 int ecode2 = 0 ;
19707 PyObject * obj0 = 0 ;
19708 PyObject * obj1 = 0 ;
19709 char * kwnames[] = {
19710 (char *) "self",(char *) "angle", NULL
19711 };
19712
19713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
19714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19715 if (!SWIG_IsOK(res1)) {
19716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
19717 }
19718 arg1 = reinterpret_cast< wxImage * >(argp1);
19719 ecode2 = SWIG_AsVal_double(obj1, &val2);
19720 if (!SWIG_IsOK(ecode2)) {
19721 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
19722 }
19723 arg2 = static_cast< double >(val2);
19724 {
19725 PyThreadState* __tstate = wxPyBeginAllowThreads();
19726 (arg1)->RotateHue(arg2);
19727 wxPyEndAllowThreads(__tstate);
19728 if (PyErr_Occurred()) SWIG_fail;
19729 }
19730 resultobj = SWIG_Py_Void();
19731 return resultobj;
19732 fail:
19733 return NULL;
19734 }
19735
19736
19737 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19738 PyObject *resultobj = 0;
19739 wxImage_RGBValue arg1 ;
19740 wxImage_HSVValue result;
19741 void *argp1 ;
19742 int res1 = 0 ;
19743 PyObject * obj0 = 0 ;
19744 char * kwnames[] = {
19745 (char *) "rgb", NULL
19746 };
19747
19748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
19749 {
19750 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
19751 if (!SWIG_IsOK(res1)) {
19752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
19753 }
19754 if (!argp1) {
19755 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
19756 } else {
19757 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
19758 arg1 = *temp;
19759 if (SWIG_IsNewObj(res1)) delete temp;
19760 }
19761 }
19762 {
19763 PyThreadState* __tstate = wxPyBeginAllowThreads();
19764 result = wxImage::RGBtoHSV(arg1);
19765 wxPyEndAllowThreads(__tstate);
19766 if (PyErr_Occurred()) SWIG_fail;
19767 }
19768 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
19769 return resultobj;
19770 fail:
19771 return NULL;
19772 }
19773
19774
19775 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19776 PyObject *resultobj = 0;
19777 wxImage_HSVValue arg1 ;
19778 wxImage_RGBValue result;
19779 void *argp1 ;
19780 int res1 = 0 ;
19781 PyObject * obj0 = 0 ;
19782 char * kwnames[] = {
19783 (char *) "hsv", NULL
19784 };
19785
19786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
19787 {
19788 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
19789 if (!SWIG_IsOK(res1)) {
19790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
19791 }
19792 if (!argp1) {
19793 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
19794 } else {
19795 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
19796 arg1 = *temp;
19797 if (SWIG_IsNewObj(res1)) delete temp;
19798 }
19799 }
19800 {
19801 PyThreadState* __tstate = wxPyBeginAllowThreads();
19802 result = wxImage::HSVtoRGB(arg1);
19803 wxPyEndAllowThreads(__tstate);
19804 if (PyErr_Occurred()) SWIG_fail;
19805 }
19806 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
19807 return resultobj;
19808 fail:
19809 return NULL;
19810 }
19811
19812
19813 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19814 PyObject *obj;
19815 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19816 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
19817 return SWIG_Py_Void();
19818 }
19819
19820 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19821 return SWIG_Python_InitShadowInstance(args);
19822 }
19823
19824 SWIGINTERN PyObject *_wrap__ImageFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19825 PyObject *resultobj = 0;
19826 int arg1 ;
19827 int arg2 ;
19828 buffer arg3 ;
19829 int arg4 ;
19830 buffer arg5 = (buffer) NULL ;
19831 int arg6 = (int) 0 ;
19832 wxImage *result = 0 ;
19833 int val1 ;
19834 int ecode1 = 0 ;
19835 int val2 ;
19836 int ecode2 = 0 ;
19837 Py_ssize_t temp3 ;
19838 Py_ssize_t temp5 ;
19839 PyObject * obj0 = 0 ;
19840 PyObject * obj1 = 0 ;
19841 PyObject * obj2 = 0 ;
19842 PyObject * obj3 = 0 ;
19843 char * kwnames[] = {
19844 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
19845 };
19846
19847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:_ImageFromBuffer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19848 ecode1 = SWIG_AsVal_int(obj0, &val1);
19849 if (!SWIG_IsOK(ecode1)) {
19850 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_ImageFromBuffer" "', expected argument " "1"" of type '" "int""'");
19851 }
19852 arg1 = static_cast< int >(val1);
19853 ecode2 = SWIG_AsVal_int(obj1, &val2);
19854 if (!SWIG_IsOK(ecode2)) {
19855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ImageFromBuffer" "', expected argument " "2"" of type '" "int""'");
19856 }
19857 arg2 = static_cast< int >(val2);
19858 {
19859 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
19860 arg4 = (int)temp3;
19861 }
19862 if (obj3) {
19863 {
19864 if (obj3 != Py_None) {
19865 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
19866 arg6 = (int)temp5;
19867 }
19868 }
19869 }
19870 {
19871 PyThreadState* __tstate = wxPyBeginAllowThreads();
19872 result = (wxImage *)_ImageFromBuffer(arg1,arg2,arg3,arg4,arg5,arg6);
19873 wxPyEndAllowThreads(__tstate);
19874 if (PyErr_Occurred()) SWIG_fail;
19875 }
19876 {
19877 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
19878 }
19879 return resultobj;
19880 fail:
19881 return NULL;
19882 }
19883
19884
19885 SWIGINTERN int NullImage_set(PyObject *) {
19886 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
19887 return 1;
19888 }
19889
19890
19891 SWIGINTERN PyObject *NullImage_get(void) {
19892 PyObject *pyobj = 0;
19893
19894 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
19895 return pyobj;
19896 }
19897
19898
19899 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
19900 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
19901 return 1;
19902 }
19903
19904
19905 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
19906 PyObject *pyobj = 0;
19907
19908 {
19909 #if wxUSE_UNICODE
19910 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
19911 #else
19912 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
19913 #endif
19914 }
19915 return pyobj;
19916 }
19917
19918
19919 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
19920 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
19921 return 1;
19922 }
19923
19924
19925 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
19926 PyObject *pyobj = 0;
19927
19928 {
19929 #if wxUSE_UNICODE
19930 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
19931 #else
19932 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
19933 #endif
19934 }
19935 return pyobj;
19936 }
19937
19938
19939 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
19940 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
19941 return 1;
19942 }
19943
19944
19945 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
19946 PyObject *pyobj = 0;
19947
19948 {
19949 #if wxUSE_UNICODE
19950 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
19951 #else
19952 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
19953 #endif
19954 }
19955 return pyobj;
19956 }
19957
19958
19959 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
19960 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
19961 return 1;
19962 }
19963
19964
19965 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
19966 PyObject *pyobj = 0;
19967
19968 {
19969 #if wxUSE_UNICODE
19970 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
19971 #else
19972 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
19973 #endif
19974 }
19975 return pyobj;
19976 }
19977
19978
19979 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
19980 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
19981 return 1;
19982 }
19983
19984
19985 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
19986 PyObject *pyobj = 0;
19987
19988 {
19989 #if wxUSE_UNICODE
19990 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
19991 #else
19992 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
19993 #endif
19994 }
19995 return pyobj;
19996 }
19997
19998
19999 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
20000 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
20001 return 1;
20002 }
20003
20004
20005 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
20006 PyObject *pyobj = 0;
20007
20008 {
20009 #if wxUSE_UNICODE
20010 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
20011 #else
20012 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
20013 #endif
20014 }
20015 return pyobj;
20016 }
20017
20018
20019 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
20020 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
20021 return 1;
20022 }
20023
20024
20025 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
20026 PyObject *pyobj = 0;
20027
20028 {
20029 #if wxUSE_UNICODE
20030 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
20031 #else
20032 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
20033 #endif
20034 }
20035 return pyobj;
20036 }
20037
20038
20039 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
20040 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
20041 return 1;
20042 }
20043
20044
20045 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
20046 PyObject *pyobj = 0;
20047
20048 {
20049 #if wxUSE_UNICODE
20050 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
20051 #else
20052 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
20053 #endif
20054 }
20055 return pyobj;
20056 }
20057
20058
20059 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
20060 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
20061 return 1;
20062 }
20063
20064
20065 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
20066 PyObject *pyobj = 0;
20067
20068 {
20069 #if wxUSE_UNICODE
20070 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
20071 #else
20072 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
20073 #endif
20074 }
20075 return pyobj;
20076 }
20077
20078
20079 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
20080 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
20081 return 1;
20082 }
20083
20084
20085 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
20086 PyObject *pyobj = 0;
20087
20088 {
20089 #if wxUSE_UNICODE
20090 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
20091 #else
20092 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
20093 #endif
20094 }
20095 return pyobj;
20096 }
20097
20098
20099 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
20100 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
20101 return 1;
20102 }
20103
20104
20105 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
20106 PyObject *pyobj = 0;
20107
20108 {
20109 #if wxUSE_UNICODE
20110 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
20111 #else
20112 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
20113 #endif
20114 }
20115 return pyobj;
20116 }
20117
20118
20119 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
20120 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
20121 return 1;
20122 }
20123
20124
20125 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
20126 PyObject *pyobj = 0;
20127
20128 {
20129 #if wxUSE_UNICODE
20130 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
20131 #else
20132 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
20133 #endif
20134 }
20135 return pyobj;
20136 }
20137
20138
20139 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
20140 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
20141 return 1;
20142 }
20143
20144
20145 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
20146 PyObject *pyobj = 0;
20147
20148 {
20149 #if wxUSE_UNICODE
20150 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
20151 #else
20152 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
20153 #endif
20154 }
20155 return pyobj;
20156 }
20157
20158
20159 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
20160 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
20161 return 1;
20162 }
20163
20164
20165 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
20166 PyObject *pyobj = 0;
20167
20168 {
20169 #if wxUSE_UNICODE
20170 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
20171 #else
20172 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
20173 #endif
20174 }
20175 return pyobj;
20176 }
20177
20178
20179 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
20180 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
20181 return 1;
20182 }
20183
20184
20185 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
20186 PyObject *pyobj = 0;
20187
20188 {
20189 #if wxUSE_UNICODE
20190 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
20191 #else
20192 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
20193 #endif
20194 }
20195 return pyobj;
20196 }
20197
20198
20199 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20200 PyObject *resultobj = 0;
20201 wxBMPHandler *result = 0 ;
20202
20203 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
20204 {
20205 PyThreadState* __tstate = wxPyBeginAllowThreads();
20206 result = (wxBMPHandler *)new wxBMPHandler();
20207 wxPyEndAllowThreads(__tstate);
20208 if (PyErr_Occurred()) SWIG_fail;
20209 }
20210 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
20211 return resultobj;
20212 fail:
20213 return NULL;
20214 }
20215
20216
20217 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20218 PyObject *obj;
20219 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20220 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
20221 return SWIG_Py_Void();
20222 }
20223
20224 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20225 return SWIG_Python_InitShadowInstance(args);
20226 }
20227
20228 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20229 PyObject *resultobj = 0;
20230 wxICOHandler *result = 0 ;
20231
20232 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
20233 {
20234 PyThreadState* __tstate = wxPyBeginAllowThreads();
20235 result = (wxICOHandler *)new wxICOHandler();
20236 wxPyEndAllowThreads(__tstate);
20237 if (PyErr_Occurred()) SWIG_fail;
20238 }
20239 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
20240 return resultobj;
20241 fail:
20242 return NULL;
20243 }
20244
20245
20246 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20247 PyObject *obj;
20248 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20249 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
20250 return SWIG_Py_Void();
20251 }
20252
20253 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20254 return SWIG_Python_InitShadowInstance(args);
20255 }
20256
20257 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20258 PyObject *resultobj = 0;
20259 wxCURHandler *result = 0 ;
20260
20261 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
20262 {
20263 PyThreadState* __tstate = wxPyBeginAllowThreads();
20264 result = (wxCURHandler *)new wxCURHandler();
20265 wxPyEndAllowThreads(__tstate);
20266 if (PyErr_Occurred()) SWIG_fail;
20267 }
20268 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
20269 return resultobj;
20270 fail:
20271 return NULL;
20272 }
20273
20274
20275 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20276 PyObject *obj;
20277 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20278 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
20279 return SWIG_Py_Void();
20280 }
20281
20282 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20283 return SWIG_Python_InitShadowInstance(args);
20284 }
20285
20286 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20287 PyObject *resultobj = 0;
20288 wxANIHandler *result = 0 ;
20289
20290 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
20291 {
20292 PyThreadState* __tstate = wxPyBeginAllowThreads();
20293 result = (wxANIHandler *)new wxANIHandler();
20294 wxPyEndAllowThreads(__tstate);
20295 if (PyErr_Occurred()) SWIG_fail;
20296 }
20297 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
20298 return resultobj;
20299 fail:
20300 return NULL;
20301 }
20302
20303
20304 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20305 PyObject *obj;
20306 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20307 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
20308 return SWIG_Py_Void();
20309 }
20310
20311 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20312 return SWIG_Python_InitShadowInstance(args);
20313 }
20314
20315 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20316 PyObject *resultobj = 0;
20317 wxPNGHandler *result = 0 ;
20318
20319 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
20320 {
20321 PyThreadState* __tstate = wxPyBeginAllowThreads();
20322 result = (wxPNGHandler *)new wxPNGHandler();
20323 wxPyEndAllowThreads(__tstate);
20324 if (PyErr_Occurred()) SWIG_fail;
20325 }
20326 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
20327 return resultobj;
20328 fail:
20329 return NULL;
20330 }
20331
20332
20333 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20334 PyObject *obj;
20335 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20336 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
20337 return SWIG_Py_Void();
20338 }
20339
20340 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20341 return SWIG_Python_InitShadowInstance(args);
20342 }
20343
20344 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20345 PyObject *resultobj = 0;
20346 wxGIFHandler *result = 0 ;
20347
20348 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
20349 {
20350 PyThreadState* __tstate = wxPyBeginAllowThreads();
20351 result = (wxGIFHandler *)new wxGIFHandler();
20352 wxPyEndAllowThreads(__tstate);
20353 if (PyErr_Occurred()) SWIG_fail;
20354 }
20355 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
20356 return resultobj;
20357 fail:
20358 return NULL;
20359 }
20360
20361
20362 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20363 PyObject *obj;
20364 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20365 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
20366 return SWIG_Py_Void();
20367 }
20368
20369 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20370 return SWIG_Python_InitShadowInstance(args);
20371 }
20372
20373 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20374 PyObject *resultobj = 0;
20375 wxPCXHandler *result = 0 ;
20376
20377 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
20378 {
20379 PyThreadState* __tstate = wxPyBeginAllowThreads();
20380 result = (wxPCXHandler *)new wxPCXHandler();
20381 wxPyEndAllowThreads(__tstate);
20382 if (PyErr_Occurred()) SWIG_fail;
20383 }
20384 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
20385 return resultobj;
20386 fail:
20387 return NULL;
20388 }
20389
20390
20391 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20392 PyObject *obj;
20393 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20394 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
20395 return SWIG_Py_Void();
20396 }
20397
20398 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20399 return SWIG_Python_InitShadowInstance(args);
20400 }
20401
20402 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20403 PyObject *resultobj = 0;
20404 wxJPEGHandler *result = 0 ;
20405
20406 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
20407 {
20408 PyThreadState* __tstate = wxPyBeginAllowThreads();
20409 result = (wxJPEGHandler *)new wxJPEGHandler();
20410 wxPyEndAllowThreads(__tstate);
20411 if (PyErr_Occurred()) SWIG_fail;
20412 }
20413 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
20414 return resultobj;
20415 fail:
20416 return NULL;
20417 }
20418
20419
20420 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20421 PyObject *obj;
20422 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20423 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
20424 return SWIG_Py_Void();
20425 }
20426
20427 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20428 return SWIG_Python_InitShadowInstance(args);
20429 }
20430
20431 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20432 PyObject *resultobj = 0;
20433 wxPNMHandler *result = 0 ;
20434
20435 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
20436 {
20437 PyThreadState* __tstate = wxPyBeginAllowThreads();
20438 result = (wxPNMHandler *)new wxPNMHandler();
20439 wxPyEndAllowThreads(__tstate);
20440 if (PyErr_Occurred()) SWIG_fail;
20441 }
20442 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
20443 return resultobj;
20444 fail:
20445 return NULL;
20446 }
20447
20448
20449 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20450 PyObject *obj;
20451 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20452 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
20453 return SWIG_Py_Void();
20454 }
20455
20456 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20457 return SWIG_Python_InitShadowInstance(args);
20458 }
20459
20460 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20461 PyObject *resultobj = 0;
20462 wxXPMHandler *result = 0 ;
20463
20464 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
20465 {
20466 PyThreadState* __tstate = wxPyBeginAllowThreads();
20467 result = (wxXPMHandler *)new wxXPMHandler();
20468 wxPyEndAllowThreads(__tstate);
20469 if (PyErr_Occurred()) SWIG_fail;
20470 }
20471 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
20472 return resultobj;
20473 fail:
20474 return NULL;
20475 }
20476
20477
20478 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20479 PyObject *obj;
20480 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20481 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
20482 return SWIG_Py_Void();
20483 }
20484
20485 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20486 return SWIG_Python_InitShadowInstance(args);
20487 }
20488
20489 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20490 PyObject *resultobj = 0;
20491 wxTIFFHandler *result = 0 ;
20492
20493 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
20494 {
20495 PyThreadState* __tstate = wxPyBeginAllowThreads();
20496 result = (wxTIFFHandler *)new wxTIFFHandler();
20497 wxPyEndAllowThreads(__tstate);
20498 if (PyErr_Occurred()) SWIG_fail;
20499 }
20500 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
20501 return resultobj;
20502 fail:
20503 return NULL;
20504 }
20505
20506
20507 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20508 PyObject *obj;
20509 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20510 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
20511 return SWIG_Py_Void();
20512 }
20513
20514 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20515 return SWIG_Python_InitShadowInstance(args);
20516 }
20517
20518 SWIGINTERN PyObject *_wrap_new_TGAHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20519 PyObject *resultobj = 0;
20520 wxTGAHandler *result = 0 ;
20521
20522 if (!SWIG_Python_UnpackTuple(args,"new_TGAHandler",0,0,0)) SWIG_fail;
20523 {
20524 PyThreadState* __tstate = wxPyBeginAllowThreads();
20525 result = (wxTGAHandler *)new wxTGAHandler();
20526 wxPyEndAllowThreads(__tstate);
20527 if (PyErr_Occurred()) SWIG_fail;
20528 }
20529 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTGAHandler, SWIG_POINTER_NEW | 0 );
20530 return resultobj;
20531 fail:
20532 return NULL;
20533 }
20534
20535
20536 SWIGINTERN PyObject *TGAHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20537 PyObject *obj;
20538 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20539 SWIG_TypeNewClientData(SWIGTYPE_p_wxTGAHandler, SWIG_NewClientData(obj));
20540 return SWIG_Py_Void();
20541 }
20542
20543 SWIGINTERN PyObject *TGAHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20544 return SWIG_Python_InitShadowInstance(args);
20545 }
20546
20547 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20548 PyObject *resultobj = 0;
20549 wxImage *arg1 = 0 ;
20550 wxImage *arg2 = 0 ;
20551 int arg3 = (int) 236 ;
20552 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
20553 bool result;
20554 void *argp1 = 0 ;
20555 int res1 = 0 ;
20556 void *argp2 = 0 ;
20557 int res2 = 0 ;
20558 int val3 ;
20559 int ecode3 = 0 ;
20560 int val4 ;
20561 int ecode4 = 0 ;
20562 PyObject * obj0 = 0 ;
20563 PyObject * obj1 = 0 ;
20564 PyObject * obj2 = 0 ;
20565 PyObject * obj3 = 0 ;
20566 char * kwnames[] = {
20567 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
20568 };
20569
20570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20571 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
20572 if (!SWIG_IsOK(res1)) {
20573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
20574 }
20575 if (!argp1) {
20576 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
20577 }
20578 arg1 = reinterpret_cast< wxImage * >(argp1);
20579 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
20580 if (!SWIG_IsOK(res2)) {
20581 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
20582 }
20583 if (!argp2) {
20584 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
20585 }
20586 arg2 = reinterpret_cast< wxImage * >(argp2);
20587 if (obj2) {
20588 ecode3 = SWIG_AsVal_int(obj2, &val3);
20589 if (!SWIG_IsOK(ecode3)) {
20590 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
20591 }
20592 arg3 = static_cast< int >(val3);
20593 }
20594 if (obj3) {
20595 ecode4 = SWIG_AsVal_int(obj3, &val4);
20596 if (!SWIG_IsOK(ecode4)) {
20597 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
20598 }
20599 arg4 = static_cast< int >(val4);
20600 }
20601 {
20602 PyThreadState* __tstate = wxPyBeginAllowThreads();
20603 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
20604 wxPyEndAllowThreads(__tstate);
20605 if (PyErr_Occurred()) SWIG_fail;
20606 }
20607 {
20608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20609 }
20610 return resultobj;
20611 fail:
20612 return NULL;
20613 }
20614
20615
20616 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20617 PyObject *obj;
20618 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20619 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
20620 return SWIG_Py_Void();
20621 }
20622
20623 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20624 PyObject *resultobj = 0;
20625 wxEvtHandler *result = 0 ;
20626
20627 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
20628 {
20629 PyThreadState* __tstate = wxPyBeginAllowThreads();
20630 result = (wxEvtHandler *)new wxEvtHandler();
20631 wxPyEndAllowThreads(__tstate);
20632 if (PyErr_Occurred()) SWIG_fail;
20633 }
20634 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
20635 return resultobj;
20636 fail:
20637 return NULL;
20638 }
20639
20640
20641 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20642 PyObject *resultobj = 0;
20643 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20644 wxEvtHandler *result = 0 ;
20645 void *argp1 = 0 ;
20646 int res1 = 0 ;
20647 PyObject *swig_obj[1] ;
20648
20649 if (!args) SWIG_fail;
20650 swig_obj[0] = args;
20651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20652 if (!SWIG_IsOK(res1)) {
20653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20654 }
20655 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20656 {
20657 PyThreadState* __tstate = wxPyBeginAllowThreads();
20658 result = (wxEvtHandler *)(arg1)->GetNextHandler();
20659 wxPyEndAllowThreads(__tstate);
20660 if (PyErr_Occurred()) SWIG_fail;
20661 }
20662 {
20663 resultobj = wxPyMake_wxObject(result, 0);
20664 }
20665 return resultobj;
20666 fail:
20667 return NULL;
20668 }
20669
20670
20671 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20672 PyObject *resultobj = 0;
20673 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20674 wxEvtHandler *result = 0 ;
20675 void *argp1 = 0 ;
20676 int res1 = 0 ;
20677 PyObject *swig_obj[1] ;
20678
20679 if (!args) SWIG_fail;
20680 swig_obj[0] = args;
20681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20682 if (!SWIG_IsOK(res1)) {
20683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20684 }
20685 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20686 {
20687 PyThreadState* __tstate = wxPyBeginAllowThreads();
20688 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
20689 wxPyEndAllowThreads(__tstate);
20690 if (PyErr_Occurred()) SWIG_fail;
20691 }
20692 {
20693 resultobj = wxPyMake_wxObject(result, 0);
20694 }
20695 return resultobj;
20696 fail:
20697 return NULL;
20698 }
20699
20700
20701 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20702 PyObject *resultobj = 0;
20703 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20704 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
20705 void *argp1 = 0 ;
20706 int res1 = 0 ;
20707 void *argp2 = 0 ;
20708 int res2 = 0 ;
20709 PyObject * obj0 = 0 ;
20710 PyObject * obj1 = 0 ;
20711 char * kwnames[] = {
20712 (char *) "self",(char *) "handler", NULL
20713 };
20714
20715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
20716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20717 if (!SWIG_IsOK(res1)) {
20718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20719 }
20720 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20721 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20722 if (!SWIG_IsOK(res2)) {
20723 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
20724 }
20725 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
20726 {
20727 PyThreadState* __tstate = wxPyBeginAllowThreads();
20728 (arg1)->SetNextHandler(arg2);
20729 wxPyEndAllowThreads(__tstate);
20730 if (PyErr_Occurred()) SWIG_fail;
20731 }
20732 resultobj = SWIG_Py_Void();
20733 return resultobj;
20734 fail:
20735 return NULL;
20736 }
20737
20738
20739 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20740 PyObject *resultobj = 0;
20741 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20742 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
20743 void *argp1 = 0 ;
20744 int res1 = 0 ;
20745 void *argp2 = 0 ;
20746 int res2 = 0 ;
20747 PyObject * obj0 = 0 ;
20748 PyObject * obj1 = 0 ;
20749 char * kwnames[] = {
20750 (char *) "self",(char *) "handler", NULL
20751 };
20752
20753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
20754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20755 if (!SWIG_IsOK(res1)) {
20756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20757 }
20758 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20759 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20760 if (!SWIG_IsOK(res2)) {
20761 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
20762 }
20763 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
20764 {
20765 PyThreadState* __tstate = wxPyBeginAllowThreads();
20766 (arg1)->SetPreviousHandler(arg2);
20767 wxPyEndAllowThreads(__tstate);
20768 if (PyErr_Occurred()) SWIG_fail;
20769 }
20770 resultobj = SWIG_Py_Void();
20771 return resultobj;
20772 fail:
20773 return NULL;
20774 }
20775
20776
20777 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20778 PyObject *resultobj = 0;
20779 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20780 bool result;
20781 void *argp1 = 0 ;
20782 int res1 = 0 ;
20783 PyObject *swig_obj[1] ;
20784
20785 if (!args) SWIG_fail;
20786 swig_obj[0] = args;
20787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20788 if (!SWIG_IsOK(res1)) {
20789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20790 }
20791 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20792 {
20793 PyThreadState* __tstate = wxPyBeginAllowThreads();
20794 result = (bool)(arg1)->GetEvtHandlerEnabled();
20795 wxPyEndAllowThreads(__tstate);
20796 if (PyErr_Occurred()) SWIG_fail;
20797 }
20798 {
20799 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20800 }
20801 return resultobj;
20802 fail:
20803 return NULL;
20804 }
20805
20806
20807 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20808 PyObject *resultobj = 0;
20809 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20810 bool arg2 ;
20811 void *argp1 = 0 ;
20812 int res1 = 0 ;
20813 bool val2 ;
20814 int ecode2 = 0 ;
20815 PyObject * obj0 = 0 ;
20816 PyObject * obj1 = 0 ;
20817 char * kwnames[] = {
20818 (char *) "self",(char *) "enabled", NULL
20819 };
20820
20821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
20822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20823 if (!SWIG_IsOK(res1)) {
20824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20825 }
20826 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20827 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20828 if (!SWIG_IsOK(ecode2)) {
20829 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
20830 }
20831 arg2 = static_cast< bool >(val2);
20832 {
20833 PyThreadState* __tstate = wxPyBeginAllowThreads();
20834 (arg1)->SetEvtHandlerEnabled(arg2);
20835 wxPyEndAllowThreads(__tstate);
20836 if (PyErr_Occurred()) SWIG_fail;
20837 }
20838 resultobj = SWIG_Py_Void();
20839 return resultobj;
20840 fail:
20841 return NULL;
20842 }
20843
20844
20845 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20846 PyObject *resultobj = 0;
20847 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20848 wxEvent *arg2 = 0 ;
20849 bool result;
20850 void *argp1 = 0 ;
20851 int res1 = 0 ;
20852 void *argp2 = 0 ;
20853 int res2 = 0 ;
20854 PyObject * obj0 = 0 ;
20855 PyObject * obj1 = 0 ;
20856 char * kwnames[] = {
20857 (char *) "self",(char *) "event", NULL
20858 };
20859
20860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
20861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20862 if (!SWIG_IsOK(res1)) {
20863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20864 }
20865 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20866 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
20867 if (!SWIG_IsOK(res2)) {
20868 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20869 }
20870 if (!argp2) {
20871 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20872 }
20873 arg2 = reinterpret_cast< wxEvent * >(argp2);
20874 {
20875 PyThreadState* __tstate = wxPyBeginAllowThreads();
20876 result = (bool)(arg1)->ProcessEvent(*arg2);
20877 wxPyEndAllowThreads(__tstate);
20878 if (PyErr_Occurred()) SWIG_fail;
20879 }
20880 {
20881 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20882 }
20883 return resultobj;
20884 fail:
20885 return NULL;
20886 }
20887
20888
20889 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20890 PyObject *resultobj = 0;
20891 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20892 wxEvent *arg2 = 0 ;
20893 void *argp1 = 0 ;
20894 int res1 = 0 ;
20895 void *argp2 = 0 ;
20896 int res2 = 0 ;
20897 PyObject * obj0 = 0 ;
20898 PyObject * obj1 = 0 ;
20899 char * kwnames[] = {
20900 (char *) "self",(char *) "event", NULL
20901 };
20902
20903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
20904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20905 if (!SWIG_IsOK(res1)) {
20906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20907 }
20908 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20909 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
20910 if (!SWIG_IsOK(res2)) {
20911 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20912 }
20913 if (!argp2) {
20914 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20915 }
20916 arg2 = reinterpret_cast< wxEvent * >(argp2);
20917 {
20918 PyThreadState* __tstate = wxPyBeginAllowThreads();
20919 (arg1)->AddPendingEvent(*arg2);
20920 wxPyEndAllowThreads(__tstate);
20921 if (PyErr_Occurred()) SWIG_fail;
20922 }
20923 resultobj = SWIG_Py_Void();
20924 return resultobj;
20925 fail:
20926 return NULL;
20927 }
20928
20929
20930 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20931 PyObject *resultobj = 0;
20932 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20933 void *argp1 = 0 ;
20934 int res1 = 0 ;
20935 PyObject *swig_obj[1] ;
20936
20937 if (!args) SWIG_fail;
20938 swig_obj[0] = args;
20939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20940 if (!SWIG_IsOK(res1)) {
20941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20942 }
20943 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20944 {
20945 PyThreadState* __tstate = wxPyBeginAllowThreads();
20946 (arg1)->ProcessPendingEvents();
20947 wxPyEndAllowThreads(__tstate);
20948 if (PyErr_Occurred()) SWIG_fail;
20949 }
20950 resultobj = SWIG_Py_Void();
20951 return resultobj;
20952 fail:
20953 return NULL;
20954 }
20955
20956
20957 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20958 PyObject *resultobj = 0;
20959 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20960 int arg2 ;
20961 int arg3 ;
20962 int arg4 ;
20963 PyObject *arg5 = (PyObject *) 0 ;
20964 void *argp1 = 0 ;
20965 int res1 = 0 ;
20966 int val2 ;
20967 int ecode2 = 0 ;
20968 int val3 ;
20969 int ecode3 = 0 ;
20970 int val4 ;
20971 int ecode4 = 0 ;
20972 PyObject * obj0 = 0 ;
20973 PyObject * obj1 = 0 ;
20974 PyObject * obj2 = 0 ;
20975 PyObject * obj3 = 0 ;
20976 PyObject * obj4 = 0 ;
20977 char * kwnames[] = {
20978 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
20979 };
20980
20981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
20982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20983 if (!SWIG_IsOK(res1)) {
20984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20985 }
20986 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20987 ecode2 = SWIG_AsVal_int(obj1, &val2);
20988 if (!SWIG_IsOK(ecode2)) {
20989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
20990 }
20991 arg2 = static_cast< int >(val2);
20992 ecode3 = SWIG_AsVal_int(obj2, &val3);
20993 if (!SWIG_IsOK(ecode3)) {
20994 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
20995 }
20996 arg3 = static_cast< int >(val3);
20997 ecode4 = SWIG_AsVal_int(obj3, &val4);
20998 if (!SWIG_IsOK(ecode4)) {
20999 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
21000 }
21001 arg4 = static_cast< int >(val4);
21002 arg5 = obj4;
21003 {
21004 PyThreadState* __tstate = wxPyBeginAllowThreads();
21005 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
21006 wxPyEndAllowThreads(__tstate);
21007 if (PyErr_Occurred()) SWIG_fail;
21008 }
21009 resultobj = SWIG_Py_Void();
21010 return resultobj;
21011 fail:
21012 return NULL;
21013 }
21014
21015
21016 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21017 PyObject *resultobj = 0;
21018 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21019 int arg2 ;
21020 int arg3 = (int) -1 ;
21021 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
21022 bool result;
21023 void *argp1 = 0 ;
21024 int res1 = 0 ;
21025 int val2 ;
21026 int ecode2 = 0 ;
21027 int val3 ;
21028 int ecode3 = 0 ;
21029 int val4 ;
21030 int ecode4 = 0 ;
21031 PyObject * obj0 = 0 ;
21032 PyObject * obj1 = 0 ;
21033 PyObject * obj2 = 0 ;
21034 PyObject * obj3 = 0 ;
21035 char * kwnames[] = {
21036 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
21037 };
21038
21039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
21040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21041 if (!SWIG_IsOK(res1)) {
21042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21043 }
21044 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21045 ecode2 = SWIG_AsVal_int(obj1, &val2);
21046 if (!SWIG_IsOK(ecode2)) {
21047 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
21048 }
21049 arg2 = static_cast< int >(val2);
21050 if (obj2) {
21051 ecode3 = SWIG_AsVal_int(obj2, &val3);
21052 if (!SWIG_IsOK(ecode3)) {
21053 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
21054 }
21055 arg3 = static_cast< int >(val3);
21056 }
21057 if (obj3) {
21058 ecode4 = SWIG_AsVal_int(obj3, &val4);
21059 if (!SWIG_IsOK(ecode4)) {
21060 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
21061 }
21062 arg4 = static_cast< wxEventType >(val4);
21063 }
21064 {
21065 PyThreadState* __tstate = wxPyBeginAllowThreads();
21066 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
21067 wxPyEndAllowThreads(__tstate);
21068 if (PyErr_Occurred()) SWIG_fail;
21069 }
21070 {
21071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21072 }
21073 return resultobj;
21074 fail:
21075 return NULL;
21076 }
21077
21078
21079 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21080 PyObject *resultobj = 0;
21081 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21082 PyObject *arg2 = (PyObject *) 0 ;
21083 bool arg3 = (bool) true ;
21084 void *argp1 = 0 ;
21085 int res1 = 0 ;
21086 bool val3 ;
21087 int ecode3 = 0 ;
21088 PyObject * obj0 = 0 ;
21089 PyObject * obj1 = 0 ;
21090 PyObject * obj2 = 0 ;
21091 char * kwnames[] = {
21092 (char *) "self",(char *) "_self",(char *) "incref", NULL
21093 };
21094
21095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21097 if (!SWIG_IsOK(res1)) {
21098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21099 }
21100 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21101 arg2 = obj1;
21102 if (obj2) {
21103 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21104 if (!SWIG_IsOK(ecode3)) {
21105 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
21106 }
21107 arg3 = static_cast< bool >(val3);
21108 }
21109 {
21110 PyThreadState* __tstate = wxPyBeginAllowThreads();
21111 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
21112 wxPyEndAllowThreads(__tstate);
21113 if (PyErr_Occurred()) SWIG_fail;
21114 }
21115 resultobj = SWIG_Py_Void();
21116 return resultobj;
21117 fail:
21118 return NULL;
21119 }
21120
21121
21122 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21123 PyObject *obj;
21124 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21125 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
21126 return SWIG_Py_Void();
21127 }
21128
21129 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21130 return SWIG_Python_InitShadowInstance(args);
21131 }
21132
21133 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21134 PyObject *resultobj = 0;
21135 wxEventType result;
21136
21137 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
21138 {
21139 PyThreadState* __tstate = wxPyBeginAllowThreads();
21140 result = (wxEventType)wxNewEventType();
21141 wxPyEndAllowThreads(__tstate);
21142 if (PyErr_Occurred()) SWIG_fail;
21143 }
21144 resultobj = SWIG_From_int(static_cast< int >(result));
21145 return resultobj;
21146 fail:
21147 return NULL;
21148 }
21149
21150
21151 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21152 PyObject *resultobj = 0;
21153 wxEvent *arg1 = (wxEvent *) 0 ;
21154 void *argp1 = 0 ;
21155 int res1 = 0 ;
21156 PyObject *swig_obj[1] ;
21157
21158 if (!args) SWIG_fail;
21159 swig_obj[0] = args;
21160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
21161 if (!SWIG_IsOK(res1)) {
21162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
21163 }
21164 arg1 = reinterpret_cast< wxEvent * >(argp1);
21165 {
21166 PyThreadState* __tstate = wxPyBeginAllowThreads();
21167 delete arg1;
21168
21169 wxPyEndAllowThreads(__tstate);
21170 if (PyErr_Occurred()) SWIG_fail;
21171 }
21172 resultobj = SWIG_Py_Void();
21173 return resultobj;
21174 fail:
21175 return NULL;
21176 }
21177
21178
21179 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21180 PyObject *resultobj = 0;
21181 wxEvent *arg1 = (wxEvent *) 0 ;
21182 wxEventType arg2 ;
21183 void *argp1 = 0 ;
21184 int res1 = 0 ;
21185 int val2 ;
21186 int ecode2 = 0 ;
21187 PyObject * obj0 = 0 ;
21188 PyObject * obj1 = 0 ;
21189 char * kwnames[] = {
21190 (char *) "self",(char *) "typ", NULL
21191 };
21192
21193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
21194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21195 if (!SWIG_IsOK(res1)) {
21196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
21197 }
21198 arg1 = reinterpret_cast< wxEvent * >(argp1);
21199 ecode2 = SWIG_AsVal_int(obj1, &val2);
21200 if (!SWIG_IsOK(ecode2)) {
21201 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
21202 }
21203 arg2 = static_cast< wxEventType >(val2);
21204 {
21205 PyThreadState* __tstate = wxPyBeginAllowThreads();
21206 (arg1)->SetEventType(arg2);
21207 wxPyEndAllowThreads(__tstate);
21208 if (PyErr_Occurred()) SWIG_fail;
21209 }
21210 resultobj = SWIG_Py_Void();
21211 return resultobj;
21212 fail:
21213 return NULL;
21214 }
21215
21216
21217 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21218 PyObject *resultobj = 0;
21219 wxEvent *arg1 = (wxEvent *) 0 ;
21220 wxEventType result;
21221 void *argp1 = 0 ;
21222 int res1 = 0 ;
21223 PyObject *swig_obj[1] ;
21224
21225 if (!args) SWIG_fail;
21226 swig_obj[0] = args;
21227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21228 if (!SWIG_IsOK(res1)) {
21229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
21230 }
21231 arg1 = reinterpret_cast< wxEvent * >(argp1);
21232 {
21233 PyThreadState* __tstate = wxPyBeginAllowThreads();
21234 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
21235 wxPyEndAllowThreads(__tstate);
21236 if (PyErr_Occurred()) SWIG_fail;
21237 }
21238 resultobj = SWIG_From_int(static_cast< int >(result));
21239 return resultobj;
21240 fail:
21241 return NULL;
21242 }
21243
21244
21245 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21246 PyObject *resultobj = 0;
21247 wxEvent *arg1 = (wxEvent *) 0 ;
21248 wxObject *result = 0 ;
21249 void *argp1 = 0 ;
21250 int res1 = 0 ;
21251 PyObject *swig_obj[1] ;
21252
21253 if (!args) SWIG_fail;
21254 swig_obj[0] = args;
21255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21256 if (!SWIG_IsOK(res1)) {
21257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
21258 }
21259 arg1 = reinterpret_cast< wxEvent * >(argp1);
21260 {
21261 PyThreadState* __tstate = wxPyBeginAllowThreads();
21262 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
21263 wxPyEndAllowThreads(__tstate);
21264 if (PyErr_Occurred()) SWIG_fail;
21265 }
21266 {
21267 resultobj = wxPyMake_wxObject(result, (bool)0);
21268 }
21269 return resultobj;
21270 fail:
21271 return NULL;
21272 }
21273
21274
21275 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21276 PyObject *resultobj = 0;
21277 wxEvent *arg1 = (wxEvent *) 0 ;
21278 wxObject *arg2 = (wxObject *) 0 ;
21279 void *argp1 = 0 ;
21280 int res1 = 0 ;
21281 void *argp2 = 0 ;
21282 int res2 = 0 ;
21283 PyObject * obj0 = 0 ;
21284 PyObject * obj1 = 0 ;
21285 char * kwnames[] = {
21286 (char *) "self",(char *) "obj", NULL
21287 };
21288
21289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
21290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21291 if (!SWIG_IsOK(res1)) {
21292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
21293 }
21294 arg1 = reinterpret_cast< wxEvent * >(argp1);
21295 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
21296 if (!SWIG_IsOK(res2)) {
21297 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
21298 }
21299 arg2 = reinterpret_cast< wxObject * >(argp2);
21300 {
21301 PyThreadState* __tstate = wxPyBeginAllowThreads();
21302 (arg1)->SetEventObject(arg2);
21303 wxPyEndAllowThreads(__tstate);
21304 if (PyErr_Occurred()) SWIG_fail;
21305 }
21306 resultobj = SWIG_Py_Void();
21307 return resultobj;
21308 fail:
21309 return NULL;
21310 }
21311
21312
21313 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21314 PyObject *resultobj = 0;
21315 wxEvent *arg1 = (wxEvent *) 0 ;
21316 long result;
21317 void *argp1 = 0 ;
21318 int res1 = 0 ;
21319 PyObject *swig_obj[1] ;
21320
21321 if (!args) SWIG_fail;
21322 swig_obj[0] = args;
21323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21324 if (!SWIG_IsOK(res1)) {
21325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
21326 }
21327 arg1 = reinterpret_cast< wxEvent * >(argp1);
21328 {
21329 PyThreadState* __tstate = wxPyBeginAllowThreads();
21330 result = (long)((wxEvent const *)arg1)->GetTimestamp();
21331 wxPyEndAllowThreads(__tstate);
21332 if (PyErr_Occurred()) SWIG_fail;
21333 }
21334 resultobj = SWIG_From_long(static_cast< long >(result));
21335 return resultobj;
21336 fail:
21337 return NULL;
21338 }
21339
21340
21341 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21342 PyObject *resultobj = 0;
21343 wxEvent *arg1 = (wxEvent *) 0 ;
21344 long arg2 = (long) 0 ;
21345 void *argp1 = 0 ;
21346 int res1 = 0 ;
21347 long val2 ;
21348 int ecode2 = 0 ;
21349 PyObject * obj0 = 0 ;
21350 PyObject * obj1 = 0 ;
21351 char * kwnames[] = {
21352 (char *) "self",(char *) "ts", NULL
21353 };
21354
21355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
21356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21357 if (!SWIG_IsOK(res1)) {
21358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
21359 }
21360 arg1 = reinterpret_cast< wxEvent * >(argp1);
21361 if (obj1) {
21362 ecode2 = SWIG_AsVal_long(obj1, &val2);
21363 if (!SWIG_IsOK(ecode2)) {
21364 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
21365 }
21366 arg2 = static_cast< long >(val2);
21367 }
21368 {
21369 PyThreadState* __tstate = wxPyBeginAllowThreads();
21370 (arg1)->SetTimestamp(arg2);
21371 wxPyEndAllowThreads(__tstate);
21372 if (PyErr_Occurred()) SWIG_fail;
21373 }
21374 resultobj = SWIG_Py_Void();
21375 return resultobj;
21376 fail:
21377 return NULL;
21378 }
21379
21380
21381 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21382 PyObject *resultobj = 0;
21383 wxEvent *arg1 = (wxEvent *) 0 ;
21384 int result;
21385 void *argp1 = 0 ;
21386 int res1 = 0 ;
21387 PyObject *swig_obj[1] ;
21388
21389 if (!args) SWIG_fail;
21390 swig_obj[0] = args;
21391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21392 if (!SWIG_IsOK(res1)) {
21393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
21394 }
21395 arg1 = reinterpret_cast< wxEvent * >(argp1);
21396 {
21397 PyThreadState* __tstate = wxPyBeginAllowThreads();
21398 result = (int)((wxEvent const *)arg1)->GetId();
21399 wxPyEndAllowThreads(__tstate);
21400 if (PyErr_Occurred()) SWIG_fail;
21401 }
21402 resultobj = SWIG_From_int(static_cast< int >(result));
21403 return resultobj;
21404 fail:
21405 return NULL;
21406 }
21407
21408
21409 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21410 PyObject *resultobj = 0;
21411 wxEvent *arg1 = (wxEvent *) 0 ;
21412 int arg2 ;
21413 void *argp1 = 0 ;
21414 int res1 = 0 ;
21415 int val2 ;
21416 int ecode2 = 0 ;
21417 PyObject * obj0 = 0 ;
21418 PyObject * obj1 = 0 ;
21419 char * kwnames[] = {
21420 (char *) "self",(char *) "Id", NULL
21421 };
21422
21423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
21424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21425 if (!SWIG_IsOK(res1)) {
21426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
21427 }
21428 arg1 = reinterpret_cast< wxEvent * >(argp1);
21429 ecode2 = SWIG_AsVal_int(obj1, &val2);
21430 if (!SWIG_IsOK(ecode2)) {
21431 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
21432 }
21433 arg2 = static_cast< int >(val2);
21434 {
21435 PyThreadState* __tstate = wxPyBeginAllowThreads();
21436 (arg1)->SetId(arg2);
21437 wxPyEndAllowThreads(__tstate);
21438 if (PyErr_Occurred()) SWIG_fail;
21439 }
21440 resultobj = SWIG_Py_Void();
21441 return resultobj;
21442 fail:
21443 return NULL;
21444 }
21445
21446
21447 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21448 PyObject *resultobj = 0;
21449 wxEvent *arg1 = (wxEvent *) 0 ;
21450 bool result;
21451 void *argp1 = 0 ;
21452 int res1 = 0 ;
21453 PyObject *swig_obj[1] ;
21454
21455 if (!args) SWIG_fail;
21456 swig_obj[0] = args;
21457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21458 if (!SWIG_IsOK(res1)) {
21459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
21460 }
21461 arg1 = reinterpret_cast< wxEvent * >(argp1);
21462 {
21463 PyThreadState* __tstate = wxPyBeginAllowThreads();
21464 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
21465 wxPyEndAllowThreads(__tstate);
21466 if (PyErr_Occurred()) SWIG_fail;
21467 }
21468 {
21469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21470 }
21471 return resultobj;
21472 fail:
21473 return NULL;
21474 }
21475
21476
21477 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21478 PyObject *resultobj = 0;
21479 wxEvent *arg1 = (wxEvent *) 0 ;
21480 bool arg2 = (bool) true ;
21481 void *argp1 = 0 ;
21482 int res1 = 0 ;
21483 bool val2 ;
21484 int ecode2 = 0 ;
21485 PyObject * obj0 = 0 ;
21486 PyObject * obj1 = 0 ;
21487 char * kwnames[] = {
21488 (char *) "self",(char *) "skip", NULL
21489 };
21490
21491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
21492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21493 if (!SWIG_IsOK(res1)) {
21494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
21495 }
21496 arg1 = reinterpret_cast< wxEvent * >(argp1);
21497 if (obj1) {
21498 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21499 if (!SWIG_IsOK(ecode2)) {
21500 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
21501 }
21502 arg2 = static_cast< bool >(val2);
21503 }
21504 {
21505 PyThreadState* __tstate = wxPyBeginAllowThreads();
21506 (arg1)->Skip(arg2);
21507 wxPyEndAllowThreads(__tstate);
21508 if (PyErr_Occurred()) SWIG_fail;
21509 }
21510 resultobj = SWIG_Py_Void();
21511 return resultobj;
21512 fail:
21513 return NULL;
21514 }
21515
21516
21517 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21518 PyObject *resultobj = 0;
21519 wxEvent *arg1 = (wxEvent *) 0 ;
21520 bool result;
21521 void *argp1 = 0 ;
21522 int res1 = 0 ;
21523 PyObject *swig_obj[1] ;
21524
21525 if (!args) SWIG_fail;
21526 swig_obj[0] = args;
21527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21528 if (!SWIG_IsOK(res1)) {
21529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
21530 }
21531 arg1 = reinterpret_cast< wxEvent * >(argp1);
21532 {
21533 PyThreadState* __tstate = wxPyBeginAllowThreads();
21534 result = (bool)((wxEvent const *)arg1)->GetSkipped();
21535 wxPyEndAllowThreads(__tstate);
21536 if (PyErr_Occurred()) SWIG_fail;
21537 }
21538 {
21539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21540 }
21541 return resultobj;
21542 fail:
21543 return NULL;
21544 }
21545
21546
21547 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21548 PyObject *resultobj = 0;
21549 wxEvent *arg1 = (wxEvent *) 0 ;
21550 bool result;
21551 void *argp1 = 0 ;
21552 int res1 = 0 ;
21553 PyObject *swig_obj[1] ;
21554
21555 if (!args) SWIG_fail;
21556 swig_obj[0] = args;
21557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21558 if (!SWIG_IsOK(res1)) {
21559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
21560 }
21561 arg1 = reinterpret_cast< wxEvent * >(argp1);
21562 {
21563 PyThreadState* __tstate = wxPyBeginAllowThreads();
21564 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
21565 wxPyEndAllowThreads(__tstate);
21566 if (PyErr_Occurred()) SWIG_fail;
21567 }
21568 {
21569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21570 }
21571 return resultobj;
21572 fail:
21573 return NULL;
21574 }
21575
21576
21577 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21578 PyObject *resultobj = 0;
21579 wxEvent *arg1 = (wxEvent *) 0 ;
21580 int result;
21581 void *argp1 = 0 ;
21582 int res1 = 0 ;
21583 PyObject *swig_obj[1] ;
21584
21585 if (!args) SWIG_fail;
21586 swig_obj[0] = args;
21587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21588 if (!SWIG_IsOK(res1)) {
21589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
21590 }
21591 arg1 = reinterpret_cast< wxEvent * >(argp1);
21592 {
21593 PyThreadState* __tstate = wxPyBeginAllowThreads();
21594 result = (int)(arg1)->StopPropagation();
21595 wxPyEndAllowThreads(__tstate);
21596 if (PyErr_Occurred()) SWIG_fail;
21597 }
21598 resultobj = SWIG_From_int(static_cast< int >(result));
21599 return resultobj;
21600 fail:
21601 return NULL;
21602 }
21603
21604
21605 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21606 PyObject *resultobj = 0;
21607 wxEvent *arg1 = (wxEvent *) 0 ;
21608 int arg2 ;
21609 void *argp1 = 0 ;
21610 int res1 = 0 ;
21611 int val2 ;
21612 int ecode2 = 0 ;
21613 PyObject * obj0 = 0 ;
21614 PyObject * obj1 = 0 ;
21615 char * kwnames[] = {
21616 (char *) "self",(char *) "propagationLevel", NULL
21617 };
21618
21619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
21620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21621 if (!SWIG_IsOK(res1)) {
21622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
21623 }
21624 arg1 = reinterpret_cast< wxEvent * >(argp1);
21625 ecode2 = SWIG_AsVal_int(obj1, &val2);
21626 if (!SWIG_IsOK(ecode2)) {
21627 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
21628 }
21629 arg2 = static_cast< int >(val2);
21630 {
21631 PyThreadState* __tstate = wxPyBeginAllowThreads();
21632 (arg1)->ResumePropagation(arg2);
21633 wxPyEndAllowThreads(__tstate);
21634 if (PyErr_Occurred()) SWIG_fail;
21635 }
21636 resultobj = SWIG_Py_Void();
21637 return resultobj;
21638 fail:
21639 return NULL;
21640 }
21641
21642
21643 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21644 PyObject *resultobj = 0;
21645 wxEvent *arg1 = (wxEvent *) 0 ;
21646 wxEvent *result = 0 ;
21647 void *argp1 = 0 ;
21648 int res1 = 0 ;
21649 PyObject *swig_obj[1] ;
21650
21651 if (!args) SWIG_fail;
21652 swig_obj[0] = args;
21653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21654 if (!SWIG_IsOK(res1)) {
21655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
21656 }
21657 arg1 = reinterpret_cast< wxEvent * >(argp1);
21658 {
21659 PyThreadState* __tstate = wxPyBeginAllowThreads();
21660 result = (wxEvent *)(arg1)->Clone();
21661 wxPyEndAllowThreads(__tstate);
21662 if (PyErr_Occurred()) SWIG_fail;
21663 }
21664 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
21665 return resultobj;
21666 fail:
21667 return NULL;
21668 }
21669
21670
21671 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21672 PyObject *obj;
21673 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21674 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
21675 return SWIG_Py_Void();
21676 }
21677
21678 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21679 PyObject *resultobj = 0;
21680 wxEvent *arg1 = 0 ;
21681 wxPropagationDisabler *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_PropagationDisabler",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_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
21693 }
21694 if (!argp1) {
21695 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
21696 }
21697 arg1 = reinterpret_cast< wxEvent * >(argp1);
21698 {
21699 PyThreadState* __tstate = wxPyBeginAllowThreads();
21700 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
21701 wxPyEndAllowThreads(__tstate);
21702 if (PyErr_Occurred()) SWIG_fail;
21703 }
21704 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
21705 return resultobj;
21706 fail:
21707 return NULL;
21708 }
21709
21710
21711 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21712 PyObject *resultobj = 0;
21713 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 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_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
21721 if (!SWIG_IsOK(res1)) {
21722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
21723 }
21724 arg1 = reinterpret_cast< wxPropagationDisabler * >(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 *PropagationDisabler_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_wxPropagationDisabler, SWIG_NewClientData(obj));
21743 return SWIG_Py_Void();
21744 }
21745
21746 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21747 return SWIG_Python_InitShadowInstance(args);
21748 }
21749
21750 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21751 PyObject *resultobj = 0;
21752 wxEvent *arg1 = 0 ;
21753 wxPropagateOnce *result = 0 ;
21754 void *argp1 = 0 ;
21755 int res1 = 0 ;
21756 PyObject * obj0 = 0 ;
21757 char * kwnames[] = {
21758 (char *) "event", NULL
21759 };
21760
21761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
21762 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
21763 if (!SWIG_IsOK(res1)) {
21764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
21765 }
21766 if (!argp1) {
21767 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
21768 }
21769 arg1 = reinterpret_cast< wxEvent * >(argp1);
21770 {
21771 PyThreadState* __tstate = wxPyBeginAllowThreads();
21772 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
21773 wxPyEndAllowThreads(__tstate);
21774 if (PyErr_Occurred()) SWIG_fail;
21775 }
21776 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
21777 return resultobj;
21778 fail:
21779 return NULL;
21780 }
21781
21782
21783 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21784 PyObject *resultobj = 0;
21785 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
21786 void *argp1 = 0 ;
21787 int res1 = 0 ;
21788 PyObject *swig_obj[1] ;
21789
21790 if (!args) SWIG_fail;
21791 swig_obj[0] = args;
21792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
21793 if (!SWIG_IsOK(res1)) {
21794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
21795 }
21796 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
21797 {
21798 PyThreadState* __tstate = wxPyBeginAllowThreads();
21799 delete arg1;
21800
21801 wxPyEndAllowThreads(__tstate);
21802 if (PyErr_Occurred()) SWIG_fail;
21803 }
21804 resultobj = SWIG_Py_Void();
21805 return resultobj;
21806 fail:
21807 return NULL;
21808 }
21809
21810
21811 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21812 PyObject *obj;
21813 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21814 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
21815 return SWIG_Py_Void();
21816 }
21817
21818 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21819 return SWIG_Python_InitShadowInstance(args);
21820 }
21821
21822 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21823 PyObject *resultobj = 0;
21824 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21825 int arg2 = (int) 0 ;
21826 wxCommandEvent *result = 0 ;
21827 int val1 ;
21828 int ecode1 = 0 ;
21829 int val2 ;
21830 int ecode2 = 0 ;
21831 PyObject * obj0 = 0 ;
21832 PyObject * obj1 = 0 ;
21833 char * kwnames[] = {
21834 (char *) "commandType",(char *) "winid", NULL
21835 };
21836
21837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21838 if (obj0) {
21839 ecode1 = SWIG_AsVal_int(obj0, &val1);
21840 if (!SWIG_IsOK(ecode1)) {
21841 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21842 }
21843 arg1 = static_cast< wxEventType >(val1);
21844 }
21845 if (obj1) {
21846 ecode2 = SWIG_AsVal_int(obj1, &val2);
21847 if (!SWIG_IsOK(ecode2)) {
21848 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
21849 }
21850 arg2 = static_cast< int >(val2);
21851 }
21852 {
21853 PyThreadState* __tstate = wxPyBeginAllowThreads();
21854 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
21855 wxPyEndAllowThreads(__tstate);
21856 if (PyErr_Occurred()) SWIG_fail;
21857 }
21858 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
21859 return resultobj;
21860 fail:
21861 return NULL;
21862 }
21863
21864
21865 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21866 PyObject *resultobj = 0;
21867 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21868 int result;
21869 void *argp1 = 0 ;
21870 int res1 = 0 ;
21871 PyObject *swig_obj[1] ;
21872
21873 if (!args) SWIG_fail;
21874 swig_obj[0] = args;
21875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21876 if (!SWIG_IsOK(res1)) {
21877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21878 }
21879 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21880 {
21881 PyThreadState* __tstate = wxPyBeginAllowThreads();
21882 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
21883 wxPyEndAllowThreads(__tstate);
21884 if (PyErr_Occurred()) SWIG_fail;
21885 }
21886 resultobj = SWIG_From_int(static_cast< int >(result));
21887 return resultobj;
21888 fail:
21889 return NULL;
21890 }
21891
21892
21893 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21894 PyObject *resultobj = 0;
21895 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21896 wxString *arg2 = 0 ;
21897 void *argp1 = 0 ;
21898 int res1 = 0 ;
21899 bool temp2 = false ;
21900 PyObject * obj0 = 0 ;
21901 PyObject * obj1 = 0 ;
21902 char * kwnames[] = {
21903 (char *) "self",(char *) "s", NULL
21904 };
21905
21906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
21907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21908 if (!SWIG_IsOK(res1)) {
21909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
21910 }
21911 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21912 {
21913 arg2 = wxString_in_helper(obj1);
21914 if (arg2 == NULL) SWIG_fail;
21915 temp2 = true;
21916 }
21917 {
21918 PyThreadState* __tstate = wxPyBeginAllowThreads();
21919 (arg1)->SetString((wxString const &)*arg2);
21920 wxPyEndAllowThreads(__tstate);
21921 if (PyErr_Occurred()) SWIG_fail;
21922 }
21923 resultobj = SWIG_Py_Void();
21924 {
21925 if (temp2)
21926 delete arg2;
21927 }
21928 return resultobj;
21929 fail:
21930 {
21931 if (temp2)
21932 delete arg2;
21933 }
21934 return NULL;
21935 }
21936
21937
21938 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21939 PyObject *resultobj = 0;
21940 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21941 wxString result;
21942 void *argp1 = 0 ;
21943 int res1 = 0 ;
21944 PyObject *swig_obj[1] ;
21945
21946 if (!args) SWIG_fail;
21947 swig_obj[0] = args;
21948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21949 if (!SWIG_IsOK(res1)) {
21950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21951 }
21952 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21953 {
21954 PyThreadState* __tstate = wxPyBeginAllowThreads();
21955 result = ((wxCommandEvent const *)arg1)->GetString();
21956 wxPyEndAllowThreads(__tstate);
21957 if (PyErr_Occurred()) SWIG_fail;
21958 }
21959 {
21960 #if wxUSE_UNICODE
21961 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21962 #else
21963 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21964 #endif
21965 }
21966 return resultobj;
21967 fail:
21968 return NULL;
21969 }
21970
21971
21972 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21973 PyObject *resultobj = 0;
21974 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21975 bool result;
21976 void *argp1 = 0 ;
21977 int res1 = 0 ;
21978 PyObject *swig_obj[1] ;
21979
21980 if (!args) SWIG_fail;
21981 swig_obj[0] = args;
21982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21983 if (!SWIG_IsOK(res1)) {
21984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21985 }
21986 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21987 {
21988 PyThreadState* __tstate = wxPyBeginAllowThreads();
21989 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
21990 wxPyEndAllowThreads(__tstate);
21991 if (PyErr_Occurred()) SWIG_fail;
21992 }
21993 {
21994 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21995 }
21996 return resultobj;
21997 fail:
21998 return NULL;
21999 }
22000
22001
22002 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22003 PyObject *resultobj = 0;
22004 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22005 bool result;
22006 void *argp1 = 0 ;
22007 int res1 = 0 ;
22008 PyObject *swig_obj[1] ;
22009
22010 if (!args) SWIG_fail;
22011 swig_obj[0] = args;
22012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22013 if (!SWIG_IsOK(res1)) {
22014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22015 }
22016 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22017 {
22018 PyThreadState* __tstate = wxPyBeginAllowThreads();
22019 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
22020 wxPyEndAllowThreads(__tstate);
22021 if (PyErr_Occurred()) SWIG_fail;
22022 }
22023 {
22024 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22025 }
22026 return resultobj;
22027 fail:
22028 return NULL;
22029 }
22030
22031
22032 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22033 PyObject *resultobj = 0;
22034 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22035 long arg2 ;
22036 void *argp1 = 0 ;
22037 int res1 = 0 ;
22038 long val2 ;
22039 int ecode2 = 0 ;
22040 PyObject * obj0 = 0 ;
22041 PyObject * obj1 = 0 ;
22042 char * kwnames[] = {
22043 (char *) "self",(char *) "extraLong", NULL
22044 };
22045
22046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
22047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22048 if (!SWIG_IsOK(res1)) {
22049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22050 }
22051 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22052 ecode2 = SWIG_AsVal_long(obj1, &val2);
22053 if (!SWIG_IsOK(ecode2)) {
22054 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
22055 }
22056 arg2 = static_cast< long >(val2);
22057 {
22058 PyThreadState* __tstate = wxPyBeginAllowThreads();
22059 (arg1)->SetExtraLong(arg2);
22060 wxPyEndAllowThreads(__tstate);
22061 if (PyErr_Occurred()) SWIG_fail;
22062 }
22063 resultobj = SWIG_Py_Void();
22064 return resultobj;
22065 fail:
22066 return NULL;
22067 }
22068
22069
22070 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22071 PyObject *resultobj = 0;
22072 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22073 long result;
22074 void *argp1 = 0 ;
22075 int res1 = 0 ;
22076 PyObject *swig_obj[1] ;
22077
22078 if (!args) SWIG_fail;
22079 swig_obj[0] = args;
22080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22081 if (!SWIG_IsOK(res1)) {
22082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22083 }
22084 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22085 {
22086 PyThreadState* __tstate = wxPyBeginAllowThreads();
22087 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
22088 wxPyEndAllowThreads(__tstate);
22089 if (PyErr_Occurred()) SWIG_fail;
22090 }
22091 resultobj = SWIG_From_long(static_cast< long >(result));
22092 return resultobj;
22093 fail:
22094 return NULL;
22095 }
22096
22097
22098 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22099 PyObject *resultobj = 0;
22100 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22101 int arg2 ;
22102 void *argp1 = 0 ;
22103 int res1 = 0 ;
22104 int val2 ;
22105 int ecode2 = 0 ;
22106 PyObject * obj0 = 0 ;
22107 PyObject * obj1 = 0 ;
22108 char * kwnames[] = {
22109 (char *) "self",(char *) "i", NULL
22110 };
22111
22112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
22113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22114 if (!SWIG_IsOK(res1)) {
22115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22116 }
22117 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22118 ecode2 = SWIG_AsVal_int(obj1, &val2);
22119 if (!SWIG_IsOK(ecode2)) {
22120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
22121 }
22122 arg2 = static_cast< int >(val2);
22123 {
22124 PyThreadState* __tstate = wxPyBeginAllowThreads();
22125 (arg1)->SetInt(arg2);
22126 wxPyEndAllowThreads(__tstate);
22127 if (PyErr_Occurred()) SWIG_fail;
22128 }
22129 resultobj = SWIG_Py_Void();
22130 return resultobj;
22131 fail:
22132 return NULL;
22133 }
22134
22135
22136 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22137 PyObject *resultobj = 0;
22138 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22139 int result;
22140 void *argp1 = 0 ;
22141 int res1 = 0 ;
22142 PyObject *swig_obj[1] ;
22143
22144 if (!args) SWIG_fail;
22145 swig_obj[0] = args;
22146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22147 if (!SWIG_IsOK(res1)) {
22148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22149 }
22150 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22151 {
22152 PyThreadState* __tstate = wxPyBeginAllowThreads();
22153 result = (int)((wxCommandEvent const *)arg1)->GetInt();
22154 wxPyEndAllowThreads(__tstate);
22155 if (PyErr_Occurred()) SWIG_fail;
22156 }
22157 resultobj = SWIG_From_int(static_cast< int >(result));
22158 return resultobj;
22159 fail:
22160 return NULL;
22161 }
22162
22163
22164 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22165 PyObject *resultobj = 0;
22166 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22167 PyObject *result = 0 ;
22168 void *argp1 = 0 ;
22169 int res1 = 0 ;
22170 PyObject *swig_obj[1] ;
22171
22172 if (!args) SWIG_fail;
22173 swig_obj[0] = args;
22174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22175 if (!SWIG_IsOK(res1)) {
22176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22177 }
22178 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22179 {
22180 PyThreadState* __tstate = wxPyBeginAllowThreads();
22181 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
22182 wxPyEndAllowThreads(__tstate);
22183 if (PyErr_Occurred()) SWIG_fail;
22184 }
22185 resultobj = result;
22186 return resultobj;
22187 fail:
22188 return NULL;
22189 }
22190
22191
22192 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22193 PyObject *resultobj = 0;
22194 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22195 PyObject *arg2 = (PyObject *) 0 ;
22196 void *argp1 = 0 ;
22197 int res1 = 0 ;
22198 PyObject * obj0 = 0 ;
22199 PyObject * obj1 = 0 ;
22200 char * kwnames[] = {
22201 (char *) "self",(char *) "clientData", NULL
22202 };
22203
22204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
22205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22206 if (!SWIG_IsOK(res1)) {
22207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22208 }
22209 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22210 arg2 = obj1;
22211 {
22212 PyThreadState* __tstate = wxPyBeginAllowThreads();
22213 wxCommandEvent_SetClientData(arg1,arg2);
22214 wxPyEndAllowThreads(__tstate);
22215 if (PyErr_Occurred()) SWIG_fail;
22216 }
22217 resultobj = SWIG_Py_Void();
22218 return resultobj;
22219 fail:
22220 return NULL;
22221 }
22222
22223
22224 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22225 PyObject *resultobj = 0;
22226 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22227 wxEvent *result = 0 ;
22228 void *argp1 = 0 ;
22229 int res1 = 0 ;
22230 PyObject *swig_obj[1] ;
22231
22232 if (!args) SWIG_fail;
22233 swig_obj[0] = args;
22234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22235 if (!SWIG_IsOK(res1)) {
22236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22237 }
22238 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22239 {
22240 PyThreadState* __tstate = wxPyBeginAllowThreads();
22241 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
22242 wxPyEndAllowThreads(__tstate);
22243 if (PyErr_Occurred()) SWIG_fail;
22244 }
22245 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
22246 return resultobj;
22247 fail:
22248 return NULL;
22249 }
22250
22251
22252 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22253 PyObject *obj;
22254 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22255 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
22256 return SWIG_Py_Void();
22257 }
22258
22259 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22260 return SWIG_Python_InitShadowInstance(args);
22261 }
22262
22263 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22264 PyObject *resultobj = 0;
22265 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22266 int arg2 = (int) 0 ;
22267 wxNotifyEvent *result = 0 ;
22268 int val1 ;
22269 int ecode1 = 0 ;
22270 int val2 ;
22271 int ecode2 = 0 ;
22272 PyObject * obj0 = 0 ;
22273 PyObject * obj1 = 0 ;
22274 char * kwnames[] = {
22275 (char *) "commandType",(char *) "winid", NULL
22276 };
22277
22278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22279 if (obj0) {
22280 ecode1 = SWIG_AsVal_int(obj0, &val1);
22281 if (!SWIG_IsOK(ecode1)) {
22282 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22283 }
22284 arg1 = static_cast< wxEventType >(val1);
22285 }
22286 if (obj1) {
22287 ecode2 = SWIG_AsVal_int(obj1, &val2);
22288 if (!SWIG_IsOK(ecode2)) {
22289 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
22290 }
22291 arg2 = static_cast< int >(val2);
22292 }
22293 {
22294 PyThreadState* __tstate = wxPyBeginAllowThreads();
22295 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
22296 wxPyEndAllowThreads(__tstate);
22297 if (PyErr_Occurred()) SWIG_fail;
22298 }
22299 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
22300 return resultobj;
22301 fail:
22302 return NULL;
22303 }
22304
22305
22306 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22307 PyObject *resultobj = 0;
22308 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22309 void *argp1 = 0 ;
22310 int res1 = 0 ;
22311 PyObject *swig_obj[1] ;
22312
22313 if (!args) SWIG_fail;
22314 swig_obj[0] = args;
22315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22316 if (!SWIG_IsOK(res1)) {
22317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22318 }
22319 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22320 {
22321 PyThreadState* __tstate = wxPyBeginAllowThreads();
22322 (arg1)->Veto();
22323 wxPyEndAllowThreads(__tstate);
22324 if (PyErr_Occurred()) SWIG_fail;
22325 }
22326 resultobj = SWIG_Py_Void();
22327 return resultobj;
22328 fail:
22329 return NULL;
22330 }
22331
22332
22333 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22334 PyObject *resultobj = 0;
22335 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22336 void *argp1 = 0 ;
22337 int res1 = 0 ;
22338 PyObject *swig_obj[1] ;
22339
22340 if (!args) SWIG_fail;
22341 swig_obj[0] = args;
22342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22343 if (!SWIG_IsOK(res1)) {
22344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22345 }
22346 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22347 {
22348 PyThreadState* __tstate = wxPyBeginAllowThreads();
22349 (arg1)->Allow();
22350 wxPyEndAllowThreads(__tstate);
22351 if (PyErr_Occurred()) SWIG_fail;
22352 }
22353 resultobj = SWIG_Py_Void();
22354 return resultobj;
22355 fail:
22356 return NULL;
22357 }
22358
22359
22360 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22361 PyObject *resultobj = 0;
22362 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22363 bool result;
22364 void *argp1 = 0 ;
22365 int res1 = 0 ;
22366 PyObject *swig_obj[1] ;
22367
22368 if (!args) SWIG_fail;
22369 swig_obj[0] = args;
22370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22371 if (!SWIG_IsOK(res1)) {
22372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22373 }
22374 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22375 {
22376 PyThreadState* __tstate = wxPyBeginAllowThreads();
22377 result = (bool)(arg1)->IsAllowed();
22378 wxPyEndAllowThreads(__tstate);
22379 if (PyErr_Occurred()) SWIG_fail;
22380 }
22381 {
22382 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22383 }
22384 return resultobj;
22385 fail:
22386 return NULL;
22387 }
22388
22389
22390 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22391 PyObject *obj;
22392 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22393 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
22394 return SWIG_Py_Void();
22395 }
22396
22397 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22398 return SWIG_Python_InitShadowInstance(args);
22399 }
22400
22401 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22402 PyObject *resultobj = 0;
22403 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22404 int arg2 = (int) 0 ;
22405 int arg3 = (int) 0 ;
22406 int arg4 = (int) 0 ;
22407 wxScrollEvent *result = 0 ;
22408 int val1 ;
22409 int ecode1 = 0 ;
22410 int val2 ;
22411 int ecode2 = 0 ;
22412 int val3 ;
22413 int ecode3 = 0 ;
22414 int val4 ;
22415 int ecode4 = 0 ;
22416 PyObject * obj0 = 0 ;
22417 PyObject * obj1 = 0 ;
22418 PyObject * obj2 = 0 ;
22419 PyObject * obj3 = 0 ;
22420 char * kwnames[] = {
22421 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
22422 };
22423
22424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22425 if (obj0) {
22426 ecode1 = SWIG_AsVal_int(obj0, &val1);
22427 if (!SWIG_IsOK(ecode1)) {
22428 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22429 }
22430 arg1 = static_cast< wxEventType >(val1);
22431 }
22432 if (obj1) {
22433 ecode2 = SWIG_AsVal_int(obj1, &val2);
22434 if (!SWIG_IsOK(ecode2)) {
22435 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
22436 }
22437 arg2 = static_cast< int >(val2);
22438 }
22439 if (obj2) {
22440 ecode3 = SWIG_AsVal_int(obj2, &val3);
22441 if (!SWIG_IsOK(ecode3)) {
22442 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
22443 }
22444 arg3 = static_cast< int >(val3);
22445 }
22446 if (obj3) {
22447 ecode4 = SWIG_AsVal_int(obj3, &val4);
22448 if (!SWIG_IsOK(ecode4)) {
22449 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
22450 }
22451 arg4 = static_cast< int >(val4);
22452 }
22453 {
22454 PyThreadState* __tstate = wxPyBeginAllowThreads();
22455 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
22456 wxPyEndAllowThreads(__tstate);
22457 if (PyErr_Occurred()) SWIG_fail;
22458 }
22459 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
22460 return resultobj;
22461 fail:
22462 return NULL;
22463 }
22464
22465
22466 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22467 PyObject *resultobj = 0;
22468 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22469 int result;
22470 void *argp1 = 0 ;
22471 int res1 = 0 ;
22472 PyObject *swig_obj[1] ;
22473
22474 if (!args) SWIG_fail;
22475 swig_obj[0] = args;
22476 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22477 if (!SWIG_IsOK(res1)) {
22478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
22479 }
22480 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22481 {
22482 PyThreadState* __tstate = wxPyBeginAllowThreads();
22483 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
22484 wxPyEndAllowThreads(__tstate);
22485 if (PyErr_Occurred()) SWIG_fail;
22486 }
22487 resultobj = SWIG_From_int(static_cast< int >(result));
22488 return resultobj;
22489 fail:
22490 return NULL;
22491 }
22492
22493
22494 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22495 PyObject *resultobj = 0;
22496 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22497 int result;
22498 void *argp1 = 0 ;
22499 int res1 = 0 ;
22500 PyObject *swig_obj[1] ;
22501
22502 if (!args) SWIG_fail;
22503 swig_obj[0] = args;
22504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22505 if (!SWIG_IsOK(res1)) {
22506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
22507 }
22508 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22509 {
22510 PyThreadState* __tstate = wxPyBeginAllowThreads();
22511 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
22512 wxPyEndAllowThreads(__tstate);
22513 if (PyErr_Occurred()) SWIG_fail;
22514 }
22515 resultobj = SWIG_From_int(static_cast< int >(result));
22516 return resultobj;
22517 fail:
22518 return NULL;
22519 }
22520
22521
22522 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22523 PyObject *resultobj = 0;
22524 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22525 int arg2 ;
22526 void *argp1 = 0 ;
22527 int res1 = 0 ;
22528 int val2 ;
22529 int ecode2 = 0 ;
22530 PyObject * obj0 = 0 ;
22531 PyObject * obj1 = 0 ;
22532 char * kwnames[] = {
22533 (char *) "self",(char *) "orient", NULL
22534 };
22535
22536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
22537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22538 if (!SWIG_IsOK(res1)) {
22539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
22540 }
22541 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22542 ecode2 = SWIG_AsVal_int(obj1, &val2);
22543 if (!SWIG_IsOK(ecode2)) {
22544 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
22545 }
22546 arg2 = static_cast< int >(val2);
22547 {
22548 PyThreadState* __tstate = wxPyBeginAllowThreads();
22549 (arg1)->SetOrientation(arg2);
22550 wxPyEndAllowThreads(__tstate);
22551 if (PyErr_Occurred()) SWIG_fail;
22552 }
22553 resultobj = SWIG_Py_Void();
22554 return resultobj;
22555 fail:
22556 return NULL;
22557 }
22558
22559
22560 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22561 PyObject *resultobj = 0;
22562 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22563 int arg2 ;
22564 void *argp1 = 0 ;
22565 int res1 = 0 ;
22566 int val2 ;
22567 int ecode2 = 0 ;
22568 PyObject * obj0 = 0 ;
22569 PyObject * obj1 = 0 ;
22570 char * kwnames[] = {
22571 (char *) "self",(char *) "pos", NULL
22572 };
22573
22574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
22575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22576 if (!SWIG_IsOK(res1)) {
22577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
22578 }
22579 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22580 ecode2 = SWIG_AsVal_int(obj1, &val2);
22581 if (!SWIG_IsOK(ecode2)) {
22582 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
22583 }
22584 arg2 = static_cast< int >(val2);
22585 {
22586 PyThreadState* __tstate = wxPyBeginAllowThreads();
22587 (arg1)->SetPosition(arg2);
22588 wxPyEndAllowThreads(__tstate);
22589 if (PyErr_Occurred()) SWIG_fail;
22590 }
22591 resultobj = SWIG_Py_Void();
22592 return resultobj;
22593 fail:
22594 return NULL;
22595 }
22596
22597
22598 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22599 PyObject *obj;
22600 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22601 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
22602 return SWIG_Py_Void();
22603 }
22604
22605 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22606 return SWIG_Python_InitShadowInstance(args);
22607 }
22608
22609 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22610 PyObject *resultobj = 0;
22611 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22612 int arg2 = (int) 0 ;
22613 int arg3 = (int) 0 ;
22614 wxScrollWinEvent *result = 0 ;
22615 int val1 ;
22616 int ecode1 = 0 ;
22617 int val2 ;
22618 int ecode2 = 0 ;
22619 int val3 ;
22620 int ecode3 = 0 ;
22621 PyObject * obj0 = 0 ;
22622 PyObject * obj1 = 0 ;
22623 PyObject * obj2 = 0 ;
22624 char * kwnames[] = {
22625 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
22626 };
22627
22628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22629 if (obj0) {
22630 ecode1 = SWIG_AsVal_int(obj0, &val1);
22631 if (!SWIG_IsOK(ecode1)) {
22632 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22633 }
22634 arg1 = static_cast< wxEventType >(val1);
22635 }
22636 if (obj1) {
22637 ecode2 = SWIG_AsVal_int(obj1, &val2);
22638 if (!SWIG_IsOK(ecode2)) {
22639 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
22640 }
22641 arg2 = static_cast< int >(val2);
22642 }
22643 if (obj2) {
22644 ecode3 = SWIG_AsVal_int(obj2, &val3);
22645 if (!SWIG_IsOK(ecode3)) {
22646 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
22647 }
22648 arg3 = static_cast< int >(val3);
22649 }
22650 {
22651 PyThreadState* __tstate = wxPyBeginAllowThreads();
22652 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
22653 wxPyEndAllowThreads(__tstate);
22654 if (PyErr_Occurred()) SWIG_fail;
22655 }
22656 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
22657 return resultobj;
22658 fail:
22659 return NULL;
22660 }
22661
22662
22663 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22664 PyObject *resultobj = 0;
22665 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22666 int result;
22667 void *argp1 = 0 ;
22668 int res1 = 0 ;
22669 PyObject *swig_obj[1] ;
22670
22671 if (!args) SWIG_fail;
22672 swig_obj[0] = args;
22673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22674 if (!SWIG_IsOK(res1)) {
22675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
22676 }
22677 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22678 {
22679 PyThreadState* __tstate = wxPyBeginAllowThreads();
22680 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
22681 wxPyEndAllowThreads(__tstate);
22682 if (PyErr_Occurred()) SWIG_fail;
22683 }
22684 resultobj = SWIG_From_int(static_cast< int >(result));
22685 return resultobj;
22686 fail:
22687 return NULL;
22688 }
22689
22690
22691 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22692 PyObject *resultobj = 0;
22693 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22694 int result;
22695 void *argp1 = 0 ;
22696 int res1 = 0 ;
22697 PyObject *swig_obj[1] ;
22698
22699 if (!args) SWIG_fail;
22700 swig_obj[0] = args;
22701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22702 if (!SWIG_IsOK(res1)) {
22703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
22704 }
22705 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22706 {
22707 PyThreadState* __tstate = wxPyBeginAllowThreads();
22708 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
22709 wxPyEndAllowThreads(__tstate);
22710 if (PyErr_Occurred()) SWIG_fail;
22711 }
22712 resultobj = SWIG_From_int(static_cast< int >(result));
22713 return resultobj;
22714 fail:
22715 return NULL;
22716 }
22717
22718
22719 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22720 PyObject *resultobj = 0;
22721 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22722 int arg2 ;
22723 void *argp1 = 0 ;
22724 int res1 = 0 ;
22725 int val2 ;
22726 int ecode2 = 0 ;
22727 PyObject * obj0 = 0 ;
22728 PyObject * obj1 = 0 ;
22729 char * kwnames[] = {
22730 (char *) "self",(char *) "orient", NULL
22731 };
22732
22733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
22734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22735 if (!SWIG_IsOK(res1)) {
22736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
22737 }
22738 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22739 ecode2 = SWIG_AsVal_int(obj1, &val2);
22740 if (!SWIG_IsOK(ecode2)) {
22741 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
22742 }
22743 arg2 = static_cast< int >(val2);
22744 {
22745 PyThreadState* __tstate = wxPyBeginAllowThreads();
22746 (arg1)->SetOrientation(arg2);
22747 wxPyEndAllowThreads(__tstate);
22748 if (PyErr_Occurred()) SWIG_fail;
22749 }
22750 resultobj = SWIG_Py_Void();
22751 return resultobj;
22752 fail:
22753 return NULL;
22754 }
22755
22756
22757 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22758 PyObject *resultobj = 0;
22759 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22760 int arg2 ;
22761 void *argp1 = 0 ;
22762 int res1 = 0 ;
22763 int val2 ;
22764 int ecode2 = 0 ;
22765 PyObject * obj0 = 0 ;
22766 PyObject * obj1 = 0 ;
22767 char * kwnames[] = {
22768 (char *) "self",(char *) "pos", NULL
22769 };
22770
22771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
22772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22773 if (!SWIG_IsOK(res1)) {
22774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
22775 }
22776 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22777 ecode2 = SWIG_AsVal_int(obj1, &val2);
22778 if (!SWIG_IsOK(ecode2)) {
22779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
22780 }
22781 arg2 = static_cast< int >(val2);
22782 {
22783 PyThreadState* __tstate = wxPyBeginAllowThreads();
22784 (arg1)->SetPosition(arg2);
22785 wxPyEndAllowThreads(__tstate);
22786 if (PyErr_Occurred()) SWIG_fail;
22787 }
22788 resultobj = SWIG_Py_Void();
22789 return resultobj;
22790 fail:
22791 return NULL;
22792 }
22793
22794
22795 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22796 PyObject *obj;
22797 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22798 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
22799 return SWIG_Py_Void();
22800 }
22801
22802 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22803 return SWIG_Python_InitShadowInstance(args);
22804 }
22805
22806 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22807 PyObject *resultobj = 0;
22808 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22809 wxMouseEvent *result = 0 ;
22810 int val1 ;
22811 int ecode1 = 0 ;
22812 PyObject * obj0 = 0 ;
22813 char * kwnames[] = {
22814 (char *) "mouseType", NULL
22815 };
22816
22817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
22818 if (obj0) {
22819 ecode1 = SWIG_AsVal_int(obj0, &val1);
22820 if (!SWIG_IsOK(ecode1)) {
22821 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22822 }
22823 arg1 = static_cast< wxEventType >(val1);
22824 }
22825 {
22826 PyThreadState* __tstate = wxPyBeginAllowThreads();
22827 result = (wxMouseEvent *)new wxMouseEvent(arg1);
22828 wxPyEndAllowThreads(__tstate);
22829 if (PyErr_Occurred()) SWIG_fail;
22830 }
22831 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_NEW | 0 );
22832 return resultobj;
22833 fail:
22834 return NULL;
22835 }
22836
22837
22838 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22839 PyObject *resultobj = 0;
22840 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22841 bool result;
22842 void *argp1 = 0 ;
22843 int res1 = 0 ;
22844 PyObject *swig_obj[1] ;
22845
22846 if (!args) SWIG_fail;
22847 swig_obj[0] = args;
22848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22849 if (!SWIG_IsOK(res1)) {
22850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22851 }
22852 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22853 {
22854 PyThreadState* __tstate = wxPyBeginAllowThreads();
22855 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
22856 wxPyEndAllowThreads(__tstate);
22857 if (PyErr_Occurred()) SWIG_fail;
22858 }
22859 {
22860 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22861 }
22862 return resultobj;
22863 fail:
22864 return NULL;
22865 }
22866
22867
22868 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22869 PyObject *resultobj = 0;
22870 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22871 int arg2 = (int) wxMOUSE_BTN_ANY ;
22872 bool result;
22873 void *argp1 = 0 ;
22874 int res1 = 0 ;
22875 int val2 ;
22876 int ecode2 = 0 ;
22877 PyObject * obj0 = 0 ;
22878 PyObject * obj1 = 0 ;
22879 char * kwnames[] = {
22880 (char *) "self",(char *) "but", NULL
22881 };
22882
22883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
22884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22885 if (!SWIG_IsOK(res1)) {
22886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22887 }
22888 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22889 if (obj1) {
22890 ecode2 = SWIG_AsVal_int(obj1, &val2);
22891 if (!SWIG_IsOK(ecode2)) {
22892 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
22893 }
22894 arg2 = static_cast< int >(val2);
22895 }
22896 {
22897 PyThreadState* __tstate = wxPyBeginAllowThreads();
22898 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
22899 wxPyEndAllowThreads(__tstate);
22900 if (PyErr_Occurred()) SWIG_fail;
22901 }
22902 {
22903 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22904 }
22905 return resultobj;
22906 fail:
22907 return NULL;
22908 }
22909
22910
22911 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22912 PyObject *resultobj = 0;
22913 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22914 int arg2 = (int) wxMOUSE_BTN_ANY ;
22915 bool result;
22916 void *argp1 = 0 ;
22917 int res1 = 0 ;
22918 int val2 ;
22919 int ecode2 = 0 ;
22920 PyObject * obj0 = 0 ;
22921 PyObject * obj1 = 0 ;
22922 char * kwnames[] = {
22923 (char *) "self",(char *) "but", NULL
22924 };
22925
22926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
22927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22928 if (!SWIG_IsOK(res1)) {
22929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22930 }
22931 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22932 if (obj1) {
22933 ecode2 = SWIG_AsVal_int(obj1, &val2);
22934 if (!SWIG_IsOK(ecode2)) {
22935 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
22936 }
22937 arg2 = static_cast< int >(val2);
22938 }
22939 {
22940 PyThreadState* __tstate = wxPyBeginAllowThreads();
22941 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
22942 wxPyEndAllowThreads(__tstate);
22943 if (PyErr_Occurred()) SWIG_fail;
22944 }
22945 {
22946 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22947 }
22948 return resultobj;
22949 fail:
22950 return NULL;
22951 }
22952
22953
22954 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22955 PyObject *resultobj = 0;
22956 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22957 int arg2 = (int) wxMOUSE_BTN_ANY ;
22958 bool result;
22959 void *argp1 = 0 ;
22960 int res1 = 0 ;
22961 int val2 ;
22962 int ecode2 = 0 ;
22963 PyObject * obj0 = 0 ;
22964 PyObject * obj1 = 0 ;
22965 char * kwnames[] = {
22966 (char *) "self",(char *) "but", NULL
22967 };
22968
22969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
22970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22971 if (!SWIG_IsOK(res1)) {
22972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22973 }
22974 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22975 if (obj1) {
22976 ecode2 = SWIG_AsVal_int(obj1, &val2);
22977 if (!SWIG_IsOK(ecode2)) {
22978 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
22979 }
22980 arg2 = static_cast< int >(val2);
22981 }
22982 {
22983 PyThreadState* __tstate = wxPyBeginAllowThreads();
22984 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
22985 wxPyEndAllowThreads(__tstate);
22986 if (PyErr_Occurred()) SWIG_fail;
22987 }
22988 {
22989 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22990 }
22991 return resultobj;
22992 fail:
22993 return NULL;
22994 }
22995
22996
22997 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22998 PyObject *resultobj = 0;
22999 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23000 int arg2 ;
23001 bool result;
23002 void *argp1 = 0 ;
23003 int res1 = 0 ;
23004 int val2 ;
23005 int ecode2 = 0 ;
23006 PyObject * obj0 = 0 ;
23007 PyObject * obj1 = 0 ;
23008 char * kwnames[] = {
23009 (char *) "self",(char *) "button", NULL
23010 };
23011
23012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
23013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23014 if (!SWIG_IsOK(res1)) {
23015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23016 }
23017 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23018 ecode2 = SWIG_AsVal_int(obj1, &val2);
23019 if (!SWIG_IsOK(ecode2)) {
23020 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
23021 }
23022 arg2 = static_cast< int >(val2);
23023 {
23024 PyThreadState* __tstate = wxPyBeginAllowThreads();
23025 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
23026 wxPyEndAllowThreads(__tstate);
23027 if (PyErr_Occurred()) SWIG_fail;
23028 }
23029 {
23030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23031 }
23032 return resultobj;
23033 fail:
23034 return NULL;
23035 }
23036
23037
23038 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23039 PyObject *resultobj = 0;
23040 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23041 int arg2 ;
23042 bool result;
23043 void *argp1 = 0 ;
23044 int res1 = 0 ;
23045 int val2 ;
23046 int ecode2 = 0 ;
23047 PyObject * obj0 = 0 ;
23048 PyObject * obj1 = 0 ;
23049 char * kwnames[] = {
23050 (char *) "self",(char *) "but", NULL
23051 };
23052
23053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
23054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23055 if (!SWIG_IsOK(res1)) {
23056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23057 }
23058 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23059 ecode2 = SWIG_AsVal_int(obj1, &val2);
23060 if (!SWIG_IsOK(ecode2)) {
23061 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
23062 }
23063 arg2 = static_cast< int >(val2);
23064 {
23065 PyThreadState* __tstate = wxPyBeginAllowThreads();
23066 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
23067 wxPyEndAllowThreads(__tstate);
23068 if (PyErr_Occurred()) SWIG_fail;
23069 }
23070 {
23071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23072 }
23073 return resultobj;
23074 fail:
23075 return NULL;
23076 }
23077
23078
23079 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23080 PyObject *resultobj = 0;
23081 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23082 int result;
23083 void *argp1 = 0 ;
23084 int res1 = 0 ;
23085 PyObject *swig_obj[1] ;
23086
23087 if (!args) SWIG_fail;
23088 swig_obj[0] = args;
23089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23090 if (!SWIG_IsOK(res1)) {
23091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23092 }
23093 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23094 {
23095 PyThreadState* __tstate = wxPyBeginAllowThreads();
23096 result = (int)((wxMouseEvent const *)arg1)->GetButton();
23097 wxPyEndAllowThreads(__tstate);
23098 if (PyErr_Occurred()) SWIG_fail;
23099 }
23100 resultobj = SWIG_From_int(static_cast< int >(result));
23101 return resultobj;
23102 fail:
23103 return NULL;
23104 }
23105
23106
23107 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23108 PyObject *resultobj = 0;
23109 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23110 bool result;
23111 void *argp1 = 0 ;
23112 int res1 = 0 ;
23113 PyObject *swig_obj[1] ;
23114
23115 if (!args) SWIG_fail;
23116 swig_obj[0] = args;
23117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23118 if (!SWIG_IsOK(res1)) {
23119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23120 }
23121 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23122 {
23123 PyThreadState* __tstate = wxPyBeginAllowThreads();
23124 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
23125 wxPyEndAllowThreads(__tstate);
23126 if (PyErr_Occurred()) SWIG_fail;
23127 }
23128 {
23129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23130 }
23131 return resultobj;
23132 fail:
23133 return NULL;
23134 }
23135
23136
23137 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23138 PyObject *resultobj = 0;
23139 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23140 bool result;
23141 void *argp1 = 0 ;
23142 int res1 = 0 ;
23143 PyObject *swig_obj[1] ;
23144
23145 if (!args) SWIG_fail;
23146 swig_obj[0] = args;
23147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23148 if (!SWIG_IsOK(res1)) {
23149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23150 }
23151 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23152 {
23153 PyThreadState* __tstate = wxPyBeginAllowThreads();
23154 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
23155 wxPyEndAllowThreads(__tstate);
23156 if (PyErr_Occurred()) SWIG_fail;
23157 }
23158 {
23159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23160 }
23161 return resultobj;
23162 fail:
23163 return NULL;
23164 }
23165
23166
23167 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23168 PyObject *resultobj = 0;
23169 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23170 bool result;
23171 void *argp1 = 0 ;
23172 int res1 = 0 ;
23173 PyObject *swig_obj[1] ;
23174
23175 if (!args) SWIG_fail;
23176 swig_obj[0] = args;
23177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23178 if (!SWIG_IsOK(res1)) {
23179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23180 }
23181 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23182 {
23183 PyThreadState* __tstate = wxPyBeginAllowThreads();
23184 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
23185 wxPyEndAllowThreads(__tstate);
23186 if (PyErr_Occurred()) SWIG_fail;
23187 }
23188 {
23189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23190 }
23191 return resultobj;
23192 fail:
23193 return NULL;
23194 }
23195
23196
23197 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23198 PyObject *resultobj = 0;
23199 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23200 bool result;
23201 void *argp1 = 0 ;
23202 int res1 = 0 ;
23203 PyObject *swig_obj[1] ;
23204
23205 if (!args) SWIG_fail;
23206 swig_obj[0] = args;
23207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23208 if (!SWIG_IsOK(res1)) {
23209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23210 }
23211 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23212 {
23213 PyThreadState* __tstate = wxPyBeginAllowThreads();
23214 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
23215 wxPyEndAllowThreads(__tstate);
23216 if (PyErr_Occurred()) SWIG_fail;
23217 }
23218 {
23219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23220 }
23221 return resultobj;
23222 fail:
23223 return NULL;
23224 }
23225
23226
23227 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23228 PyObject *resultobj = 0;
23229 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23230 bool result;
23231 void *argp1 = 0 ;
23232 int res1 = 0 ;
23233 PyObject *swig_obj[1] ;
23234
23235 if (!args) SWIG_fail;
23236 swig_obj[0] = args;
23237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23238 if (!SWIG_IsOK(res1)) {
23239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23240 }
23241 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23242 {
23243 PyThreadState* __tstate = wxPyBeginAllowThreads();
23244 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
23245 wxPyEndAllowThreads(__tstate);
23246 if (PyErr_Occurred()) SWIG_fail;
23247 }
23248 {
23249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23250 }
23251 return resultobj;
23252 fail:
23253 return NULL;
23254 }
23255
23256
23257 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23258 PyObject *resultobj = 0;
23259 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23260 bool result;
23261 void *argp1 = 0 ;
23262 int res1 = 0 ;
23263 PyObject *swig_obj[1] ;
23264
23265 if (!args) SWIG_fail;
23266 swig_obj[0] = args;
23267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23268 if (!SWIG_IsOK(res1)) {
23269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23270 }
23271 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23272 {
23273 PyThreadState* __tstate = wxPyBeginAllowThreads();
23274 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
23275 wxPyEndAllowThreads(__tstate);
23276 if (PyErr_Occurred()) SWIG_fail;
23277 }
23278 {
23279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23280 }
23281 return resultobj;
23282 fail:
23283 return NULL;
23284 }
23285
23286
23287 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23288 PyObject *resultobj = 0;
23289 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23290 bool result;
23291 void *argp1 = 0 ;
23292 int res1 = 0 ;
23293 PyObject *swig_obj[1] ;
23294
23295 if (!args) SWIG_fail;
23296 swig_obj[0] = args;
23297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23298 if (!SWIG_IsOK(res1)) {
23299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23300 }
23301 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23302 {
23303 PyThreadState* __tstate = wxPyBeginAllowThreads();
23304 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
23305 wxPyEndAllowThreads(__tstate);
23306 if (PyErr_Occurred()) SWIG_fail;
23307 }
23308 {
23309 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23310 }
23311 return resultobj;
23312 fail:
23313 return NULL;
23314 }
23315
23316
23317 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23318 PyObject *resultobj = 0;
23319 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23320 bool result;
23321 void *argp1 = 0 ;
23322 int res1 = 0 ;
23323 PyObject *swig_obj[1] ;
23324
23325 if (!args) SWIG_fail;
23326 swig_obj[0] = args;
23327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23328 if (!SWIG_IsOK(res1)) {
23329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23330 }
23331 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23332 {
23333 PyThreadState* __tstate = wxPyBeginAllowThreads();
23334 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
23335 wxPyEndAllowThreads(__tstate);
23336 if (PyErr_Occurred()) SWIG_fail;
23337 }
23338 {
23339 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23340 }
23341 return resultobj;
23342 fail:
23343 return NULL;
23344 }
23345
23346
23347 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23348 PyObject *resultobj = 0;
23349 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23350 bool result;
23351 void *argp1 = 0 ;
23352 int res1 = 0 ;
23353 PyObject *swig_obj[1] ;
23354
23355 if (!args) SWIG_fail;
23356 swig_obj[0] = args;
23357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23358 if (!SWIG_IsOK(res1)) {
23359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23360 }
23361 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23362 {
23363 PyThreadState* __tstate = wxPyBeginAllowThreads();
23364 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
23365 wxPyEndAllowThreads(__tstate);
23366 if (PyErr_Occurred()) SWIG_fail;
23367 }
23368 {
23369 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23370 }
23371 return resultobj;
23372 fail:
23373 return NULL;
23374 }
23375
23376
23377 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23378 PyObject *resultobj = 0;
23379 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23380 bool result;
23381 void *argp1 = 0 ;
23382 int res1 = 0 ;
23383 PyObject *swig_obj[1] ;
23384
23385 if (!args) SWIG_fail;
23386 swig_obj[0] = args;
23387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23388 if (!SWIG_IsOK(res1)) {
23389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23390 }
23391 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23392 {
23393 PyThreadState* __tstate = wxPyBeginAllowThreads();
23394 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
23395 wxPyEndAllowThreads(__tstate);
23396 if (PyErr_Occurred()) SWIG_fail;
23397 }
23398 {
23399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23400 }
23401 return resultobj;
23402 fail:
23403 return NULL;
23404 }
23405
23406
23407 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23408 PyObject *resultobj = 0;
23409 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23410 bool result;
23411 void *argp1 = 0 ;
23412 int res1 = 0 ;
23413 PyObject *swig_obj[1] ;
23414
23415 if (!args) SWIG_fail;
23416 swig_obj[0] = args;
23417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23418 if (!SWIG_IsOK(res1)) {
23419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23420 }
23421 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23422 {
23423 PyThreadState* __tstate = wxPyBeginAllowThreads();
23424 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
23425 wxPyEndAllowThreads(__tstate);
23426 if (PyErr_Occurred()) SWIG_fail;
23427 }
23428 {
23429 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23430 }
23431 return resultobj;
23432 fail:
23433 return NULL;
23434 }
23435
23436
23437 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23438 PyObject *resultobj = 0;
23439 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23440 bool result;
23441 void *argp1 = 0 ;
23442 int res1 = 0 ;
23443 PyObject *swig_obj[1] ;
23444
23445 if (!args) SWIG_fail;
23446 swig_obj[0] = args;
23447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23448 if (!SWIG_IsOK(res1)) {
23449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23450 }
23451 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23452 {
23453 PyThreadState* __tstate = wxPyBeginAllowThreads();
23454 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
23455 wxPyEndAllowThreads(__tstate);
23456 if (PyErr_Occurred()) SWIG_fail;
23457 }
23458 {
23459 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23460 }
23461 return resultobj;
23462 fail:
23463 return NULL;
23464 }
23465
23466
23467 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23468 PyObject *resultobj = 0;
23469 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23470 bool result;
23471 void *argp1 = 0 ;
23472 int res1 = 0 ;
23473 PyObject *swig_obj[1] ;
23474
23475 if (!args) SWIG_fail;
23476 swig_obj[0] = args;
23477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23478 if (!SWIG_IsOK(res1)) {
23479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23480 }
23481 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23482 {
23483 PyThreadState* __tstate = wxPyBeginAllowThreads();
23484 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
23485 wxPyEndAllowThreads(__tstate);
23486 if (PyErr_Occurred()) SWIG_fail;
23487 }
23488 {
23489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23490 }
23491 return resultobj;
23492 fail:
23493 return NULL;
23494 }
23495
23496
23497 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23498 PyObject *resultobj = 0;
23499 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23500 bool result;
23501 void *argp1 = 0 ;
23502 int res1 = 0 ;
23503 PyObject *swig_obj[1] ;
23504
23505 if (!args) SWIG_fail;
23506 swig_obj[0] = args;
23507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23508 if (!SWIG_IsOK(res1)) {
23509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23510 }
23511 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23512 {
23513 PyThreadState* __tstate = wxPyBeginAllowThreads();
23514 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
23515 wxPyEndAllowThreads(__tstate);
23516 if (PyErr_Occurred()) SWIG_fail;
23517 }
23518 {
23519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23520 }
23521 return resultobj;
23522 fail:
23523 return NULL;
23524 }
23525
23526
23527 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23528 PyObject *resultobj = 0;
23529 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23530 bool result;
23531 void *argp1 = 0 ;
23532 int res1 = 0 ;
23533 PyObject *swig_obj[1] ;
23534
23535 if (!args) SWIG_fail;
23536 swig_obj[0] = args;
23537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23538 if (!SWIG_IsOK(res1)) {
23539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23540 }
23541 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23542 {
23543 PyThreadState* __tstate = wxPyBeginAllowThreads();
23544 result = (bool)(arg1)->LeftIsDown();
23545 wxPyEndAllowThreads(__tstate);
23546 if (PyErr_Occurred()) SWIG_fail;
23547 }
23548 {
23549 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23550 }
23551 return resultobj;
23552 fail:
23553 return NULL;
23554 }
23555
23556
23557 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23558 PyObject *resultobj = 0;
23559 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23560 bool result;
23561 void *argp1 = 0 ;
23562 int res1 = 0 ;
23563 PyObject *swig_obj[1] ;
23564
23565 if (!args) SWIG_fail;
23566 swig_obj[0] = args;
23567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23568 if (!SWIG_IsOK(res1)) {
23569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23570 }
23571 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23572 {
23573 PyThreadState* __tstate = wxPyBeginAllowThreads();
23574 result = (bool)(arg1)->MiddleIsDown();
23575 wxPyEndAllowThreads(__tstate);
23576 if (PyErr_Occurred()) SWIG_fail;
23577 }
23578 {
23579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23580 }
23581 return resultobj;
23582 fail:
23583 return NULL;
23584 }
23585
23586
23587 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23588 PyObject *resultobj = 0;
23589 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23590 bool result;
23591 void *argp1 = 0 ;
23592 int res1 = 0 ;
23593 PyObject *swig_obj[1] ;
23594
23595 if (!args) SWIG_fail;
23596 swig_obj[0] = args;
23597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23598 if (!SWIG_IsOK(res1)) {
23599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23600 }
23601 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23602 {
23603 PyThreadState* __tstate = wxPyBeginAllowThreads();
23604 result = (bool)(arg1)->RightIsDown();
23605 wxPyEndAllowThreads(__tstate);
23606 if (PyErr_Occurred()) SWIG_fail;
23607 }
23608 {
23609 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23610 }
23611 return resultobj;
23612 fail:
23613 return NULL;
23614 }
23615
23616
23617 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23618 PyObject *resultobj = 0;
23619 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23620 bool result;
23621 void *argp1 = 0 ;
23622 int res1 = 0 ;
23623 PyObject *swig_obj[1] ;
23624
23625 if (!args) SWIG_fail;
23626 swig_obj[0] = args;
23627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23628 if (!SWIG_IsOK(res1)) {
23629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23630 }
23631 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23632 {
23633 PyThreadState* __tstate = wxPyBeginAllowThreads();
23634 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
23635 wxPyEndAllowThreads(__tstate);
23636 if (PyErr_Occurred()) SWIG_fail;
23637 }
23638 {
23639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23640 }
23641 return resultobj;
23642 fail:
23643 return NULL;
23644 }
23645
23646
23647 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23648 PyObject *resultobj = 0;
23649 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23650 bool result;
23651 void *argp1 = 0 ;
23652 int res1 = 0 ;
23653 PyObject *swig_obj[1] ;
23654
23655 if (!args) SWIG_fail;
23656 swig_obj[0] = args;
23657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23658 if (!SWIG_IsOK(res1)) {
23659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23660 }
23661 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23662 {
23663 PyThreadState* __tstate = wxPyBeginAllowThreads();
23664 result = (bool)((wxMouseEvent const *)arg1)->Moving();
23665 wxPyEndAllowThreads(__tstate);
23666 if (PyErr_Occurred()) SWIG_fail;
23667 }
23668 {
23669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23670 }
23671 return resultobj;
23672 fail:
23673 return NULL;
23674 }
23675
23676
23677 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23678 PyObject *resultobj = 0;
23679 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23680 bool result;
23681 void *argp1 = 0 ;
23682 int res1 = 0 ;
23683 PyObject *swig_obj[1] ;
23684
23685 if (!args) SWIG_fail;
23686 swig_obj[0] = args;
23687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23688 if (!SWIG_IsOK(res1)) {
23689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23690 }
23691 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23692 {
23693 PyThreadState* __tstate = wxPyBeginAllowThreads();
23694 result = (bool)((wxMouseEvent const *)arg1)->Entering();
23695 wxPyEndAllowThreads(__tstate);
23696 if (PyErr_Occurred()) SWIG_fail;
23697 }
23698 {
23699 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23700 }
23701 return resultobj;
23702 fail:
23703 return NULL;
23704 }
23705
23706
23707 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23708 PyObject *resultobj = 0;
23709 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23710 bool result;
23711 void *argp1 = 0 ;
23712 int res1 = 0 ;
23713 PyObject *swig_obj[1] ;
23714
23715 if (!args) SWIG_fail;
23716 swig_obj[0] = args;
23717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23718 if (!SWIG_IsOK(res1)) {
23719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23720 }
23721 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23722 {
23723 PyThreadState* __tstate = wxPyBeginAllowThreads();
23724 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
23725 wxPyEndAllowThreads(__tstate);
23726 if (PyErr_Occurred()) SWIG_fail;
23727 }
23728 {
23729 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23730 }
23731 return resultobj;
23732 fail:
23733 return NULL;
23734 }
23735
23736
23737 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23738 PyObject *resultobj = 0;
23739 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23740 wxPoint result;
23741 void *argp1 = 0 ;
23742 int res1 = 0 ;
23743 PyObject *swig_obj[1] ;
23744
23745 if (!args) SWIG_fail;
23746 swig_obj[0] = args;
23747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23748 if (!SWIG_IsOK(res1)) {
23749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23750 }
23751 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23752 {
23753 PyThreadState* __tstate = wxPyBeginAllowThreads();
23754 result = (arg1)->GetPosition();
23755 wxPyEndAllowThreads(__tstate);
23756 if (PyErr_Occurred()) SWIG_fail;
23757 }
23758 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23759 return resultobj;
23760 fail:
23761 return NULL;
23762 }
23763
23764
23765 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23766 PyObject *resultobj = 0;
23767 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23768 long *arg2 = (long *) 0 ;
23769 long *arg3 = (long *) 0 ;
23770 void *argp1 = 0 ;
23771 int res1 = 0 ;
23772 long temp2 ;
23773 int res2 = SWIG_TMPOBJ ;
23774 long temp3 ;
23775 int res3 = SWIG_TMPOBJ ;
23776 PyObject *swig_obj[1] ;
23777
23778 arg2 = &temp2;
23779 arg3 = &temp3;
23780 if (!args) SWIG_fail;
23781 swig_obj[0] = args;
23782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23783 if (!SWIG_IsOK(res1)) {
23784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23785 }
23786 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23787 {
23788 PyThreadState* __tstate = wxPyBeginAllowThreads();
23789 (arg1)->GetPosition(arg2,arg3);
23790 wxPyEndAllowThreads(__tstate);
23791 if (PyErr_Occurred()) SWIG_fail;
23792 }
23793 resultobj = SWIG_Py_Void();
23794 if (SWIG_IsTmpObj(res2)) {
23795 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
23796 } else {
23797 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23798 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
23799 }
23800 if (SWIG_IsTmpObj(res3)) {
23801 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
23802 } else {
23803 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23804 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
23805 }
23806 return resultobj;
23807 fail:
23808 return NULL;
23809 }
23810
23811
23812 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23813 PyObject *resultobj = 0;
23814 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23815 wxDC *arg2 = 0 ;
23816 wxPoint result;
23817 void *argp1 = 0 ;
23818 int res1 = 0 ;
23819 void *argp2 = 0 ;
23820 int res2 = 0 ;
23821 PyObject * obj0 = 0 ;
23822 PyObject * obj1 = 0 ;
23823 char * kwnames[] = {
23824 (char *) "self",(char *) "dc", NULL
23825 };
23826
23827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23829 if (!SWIG_IsOK(res1)) {
23830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23831 }
23832 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23833 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
23834 if (!SWIG_IsOK(res2)) {
23835 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
23836 }
23837 if (!argp2) {
23838 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
23839 }
23840 arg2 = reinterpret_cast< wxDC * >(argp2);
23841 {
23842 PyThreadState* __tstate = wxPyBeginAllowThreads();
23843 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
23844 wxPyEndAllowThreads(__tstate);
23845 if (PyErr_Occurred()) SWIG_fail;
23846 }
23847 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23848 return resultobj;
23849 fail:
23850 return NULL;
23851 }
23852
23853
23854 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23855 PyObject *resultobj = 0;
23856 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23857 int result;
23858 void *argp1 = 0 ;
23859 int res1 = 0 ;
23860 PyObject *swig_obj[1] ;
23861
23862 if (!args) SWIG_fail;
23863 swig_obj[0] = args;
23864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23865 if (!SWIG_IsOK(res1)) {
23866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23867 }
23868 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23869 {
23870 PyThreadState* __tstate = wxPyBeginAllowThreads();
23871 result = (int)((wxMouseEvent const *)arg1)->GetX();
23872 wxPyEndAllowThreads(__tstate);
23873 if (PyErr_Occurred()) SWIG_fail;
23874 }
23875 resultobj = SWIG_From_int(static_cast< int >(result));
23876 return resultobj;
23877 fail:
23878 return NULL;
23879 }
23880
23881
23882 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23883 PyObject *resultobj = 0;
23884 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23885 int result;
23886 void *argp1 = 0 ;
23887 int res1 = 0 ;
23888 PyObject *swig_obj[1] ;
23889
23890 if (!args) SWIG_fail;
23891 swig_obj[0] = args;
23892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23893 if (!SWIG_IsOK(res1)) {
23894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23895 }
23896 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23897 {
23898 PyThreadState* __tstate = wxPyBeginAllowThreads();
23899 result = (int)((wxMouseEvent const *)arg1)->GetY();
23900 wxPyEndAllowThreads(__tstate);
23901 if (PyErr_Occurred()) SWIG_fail;
23902 }
23903 resultobj = SWIG_From_int(static_cast< int >(result));
23904 return resultobj;
23905 fail:
23906 return NULL;
23907 }
23908
23909
23910 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23911 PyObject *resultobj = 0;
23912 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23913 int result;
23914 void *argp1 = 0 ;
23915 int res1 = 0 ;
23916 PyObject *swig_obj[1] ;
23917
23918 if (!args) SWIG_fail;
23919 swig_obj[0] = args;
23920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23921 if (!SWIG_IsOK(res1)) {
23922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23923 }
23924 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23925 {
23926 PyThreadState* __tstate = wxPyBeginAllowThreads();
23927 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
23928 wxPyEndAllowThreads(__tstate);
23929 if (PyErr_Occurred()) SWIG_fail;
23930 }
23931 resultobj = SWIG_From_int(static_cast< int >(result));
23932 return resultobj;
23933 fail:
23934 return NULL;
23935 }
23936
23937
23938 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23939 PyObject *resultobj = 0;
23940 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23941 int result;
23942 void *argp1 = 0 ;
23943 int res1 = 0 ;
23944 PyObject *swig_obj[1] ;
23945
23946 if (!args) SWIG_fail;
23947 swig_obj[0] = args;
23948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23949 if (!SWIG_IsOK(res1)) {
23950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23951 }
23952 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23953 {
23954 PyThreadState* __tstate = wxPyBeginAllowThreads();
23955 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
23956 wxPyEndAllowThreads(__tstate);
23957 if (PyErr_Occurred()) SWIG_fail;
23958 }
23959 resultobj = SWIG_From_int(static_cast< int >(result));
23960 return resultobj;
23961 fail:
23962 return NULL;
23963 }
23964
23965
23966 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelAxis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23967 PyObject *resultobj = 0;
23968 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23969 int result;
23970 void *argp1 = 0 ;
23971 int res1 = 0 ;
23972 PyObject *swig_obj[1] ;
23973
23974 if (!args) SWIG_fail;
23975 swig_obj[0] = args;
23976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23977 if (!SWIG_IsOK(res1)) {
23978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelAxis" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23979 }
23980 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23981 {
23982 PyThreadState* __tstate = wxPyBeginAllowThreads();
23983 result = (int)((wxMouseEvent const *)arg1)->GetWheelAxis();
23984 wxPyEndAllowThreads(__tstate);
23985 if (PyErr_Occurred()) SWIG_fail;
23986 }
23987 resultobj = SWIG_From_int(static_cast< int >(result));
23988 return resultobj;
23989 fail:
23990 return NULL;
23991 }
23992
23993
23994 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23995 PyObject *resultobj = 0;
23996 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23997 int result;
23998 void *argp1 = 0 ;
23999 int res1 = 0 ;
24000 PyObject *swig_obj[1] ;
24001
24002 if (!args) SWIG_fail;
24003 swig_obj[0] = args;
24004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24005 if (!SWIG_IsOK(res1)) {
24006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24007 }
24008 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24009 {
24010 PyThreadState* __tstate = wxPyBeginAllowThreads();
24011 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
24012 wxPyEndAllowThreads(__tstate);
24013 if (PyErr_Occurred()) SWIG_fail;
24014 }
24015 resultobj = SWIG_From_int(static_cast< int >(result));
24016 return resultobj;
24017 fail:
24018 return NULL;
24019 }
24020
24021
24022 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24023 PyObject *resultobj = 0;
24024 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24025 bool result;
24026 void *argp1 = 0 ;
24027 int res1 = 0 ;
24028 PyObject *swig_obj[1] ;
24029
24030 if (!args) SWIG_fail;
24031 swig_obj[0] = args;
24032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24033 if (!SWIG_IsOK(res1)) {
24034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24035 }
24036 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24037 {
24038 PyThreadState* __tstate = wxPyBeginAllowThreads();
24039 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
24040 wxPyEndAllowThreads(__tstate);
24041 if (PyErr_Occurred()) SWIG_fail;
24042 }
24043 {
24044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24045 }
24046 return resultobj;
24047 fail:
24048 return NULL;
24049 }
24050
24051
24052 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24053 PyObject *resultobj = 0;
24054 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24055 int arg2 ;
24056 void *argp1 = 0 ;
24057 int res1 = 0 ;
24058 int val2 ;
24059 int ecode2 = 0 ;
24060 PyObject *swig_obj[2] ;
24061
24062 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
24063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24064 if (!SWIG_IsOK(res1)) {
24065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24066 }
24067 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24068 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24069 if (!SWIG_IsOK(ecode2)) {
24070 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
24071 }
24072 arg2 = static_cast< int >(val2);
24073 if (arg1) (arg1)->m_x = arg2;
24074
24075 resultobj = SWIG_Py_Void();
24076 return resultobj;
24077 fail:
24078 return NULL;
24079 }
24080
24081
24082 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24083 PyObject *resultobj = 0;
24084 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24085 int result;
24086 void *argp1 = 0 ;
24087 int res1 = 0 ;
24088 PyObject *swig_obj[1] ;
24089
24090 if (!args) SWIG_fail;
24091 swig_obj[0] = args;
24092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24093 if (!SWIG_IsOK(res1)) {
24094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24095 }
24096 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24097 result = (int) ((arg1)->m_x);
24098 resultobj = SWIG_From_int(static_cast< int >(result));
24099 return resultobj;
24100 fail:
24101 return NULL;
24102 }
24103
24104
24105 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24106 PyObject *resultobj = 0;
24107 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24108 int arg2 ;
24109 void *argp1 = 0 ;
24110 int res1 = 0 ;
24111 int val2 ;
24112 int ecode2 = 0 ;
24113 PyObject *swig_obj[2] ;
24114
24115 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
24116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24117 if (!SWIG_IsOK(res1)) {
24118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24119 }
24120 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24121 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24122 if (!SWIG_IsOK(ecode2)) {
24123 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
24124 }
24125 arg2 = static_cast< int >(val2);
24126 if (arg1) (arg1)->m_y = arg2;
24127
24128 resultobj = SWIG_Py_Void();
24129 return resultobj;
24130 fail:
24131 return NULL;
24132 }
24133
24134
24135 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24136 PyObject *resultobj = 0;
24137 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24138 int result;
24139 void *argp1 = 0 ;
24140 int res1 = 0 ;
24141 PyObject *swig_obj[1] ;
24142
24143 if (!args) SWIG_fail;
24144 swig_obj[0] = args;
24145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24146 if (!SWIG_IsOK(res1)) {
24147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24148 }
24149 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24150 result = (int) ((arg1)->m_y);
24151 resultobj = SWIG_From_int(static_cast< int >(result));
24152 return resultobj;
24153 fail:
24154 return NULL;
24155 }
24156
24157
24158 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24159 PyObject *resultobj = 0;
24160 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24161 bool arg2 ;
24162 void *argp1 = 0 ;
24163 int res1 = 0 ;
24164 bool val2 ;
24165 int ecode2 = 0 ;
24166 PyObject *swig_obj[2] ;
24167
24168 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
24169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24170 if (!SWIG_IsOK(res1)) {
24171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24172 }
24173 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24174 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24175 if (!SWIG_IsOK(ecode2)) {
24176 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
24177 }
24178 arg2 = static_cast< bool >(val2);
24179 if (arg1) (arg1)->m_leftDown = arg2;
24180
24181 resultobj = SWIG_Py_Void();
24182 return resultobj;
24183 fail:
24184 return NULL;
24185 }
24186
24187
24188 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24189 PyObject *resultobj = 0;
24190 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24191 bool result;
24192 void *argp1 = 0 ;
24193 int res1 = 0 ;
24194 PyObject *swig_obj[1] ;
24195
24196 if (!args) SWIG_fail;
24197 swig_obj[0] = args;
24198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24199 if (!SWIG_IsOK(res1)) {
24200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24201 }
24202 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24203 result = (bool) ((arg1)->m_leftDown);
24204 {
24205 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24206 }
24207 return resultobj;
24208 fail:
24209 return NULL;
24210 }
24211
24212
24213 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24214 PyObject *resultobj = 0;
24215 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24216 bool arg2 ;
24217 void *argp1 = 0 ;
24218 int res1 = 0 ;
24219 bool val2 ;
24220 int ecode2 = 0 ;
24221 PyObject *swig_obj[2] ;
24222
24223 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
24224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24225 if (!SWIG_IsOK(res1)) {
24226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24227 }
24228 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24229 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24230 if (!SWIG_IsOK(ecode2)) {
24231 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
24232 }
24233 arg2 = static_cast< bool >(val2);
24234 if (arg1) (arg1)->m_middleDown = arg2;
24235
24236 resultobj = SWIG_Py_Void();
24237 return resultobj;
24238 fail:
24239 return NULL;
24240 }
24241
24242
24243 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24244 PyObject *resultobj = 0;
24245 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24246 bool result;
24247 void *argp1 = 0 ;
24248 int res1 = 0 ;
24249 PyObject *swig_obj[1] ;
24250
24251 if (!args) SWIG_fail;
24252 swig_obj[0] = args;
24253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24254 if (!SWIG_IsOK(res1)) {
24255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24256 }
24257 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24258 result = (bool) ((arg1)->m_middleDown);
24259 {
24260 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24261 }
24262 return resultobj;
24263 fail:
24264 return NULL;
24265 }
24266
24267
24268 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24269 PyObject *resultobj = 0;
24270 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24271 bool arg2 ;
24272 void *argp1 = 0 ;
24273 int res1 = 0 ;
24274 bool val2 ;
24275 int ecode2 = 0 ;
24276 PyObject *swig_obj[2] ;
24277
24278 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
24279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24280 if (!SWIG_IsOK(res1)) {
24281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24282 }
24283 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24284 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24285 if (!SWIG_IsOK(ecode2)) {
24286 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
24287 }
24288 arg2 = static_cast< bool >(val2);
24289 if (arg1) (arg1)->m_rightDown = arg2;
24290
24291 resultobj = SWIG_Py_Void();
24292 return resultobj;
24293 fail:
24294 return NULL;
24295 }
24296
24297
24298 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24299 PyObject *resultobj = 0;
24300 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24301 bool result;
24302 void *argp1 = 0 ;
24303 int res1 = 0 ;
24304 PyObject *swig_obj[1] ;
24305
24306 if (!args) SWIG_fail;
24307 swig_obj[0] = args;
24308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24309 if (!SWIG_IsOK(res1)) {
24310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24311 }
24312 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24313 result = (bool) ((arg1)->m_rightDown);
24314 {
24315 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24316 }
24317 return resultobj;
24318 fail:
24319 return NULL;
24320 }
24321
24322
24323 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24324 PyObject *resultobj = 0;
24325 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24326 bool arg2 ;
24327 void *argp1 = 0 ;
24328 int res1 = 0 ;
24329 bool val2 ;
24330 int ecode2 = 0 ;
24331 PyObject *swig_obj[2] ;
24332
24333 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
24334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24335 if (!SWIG_IsOK(res1)) {
24336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24337 }
24338 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24339 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24340 if (!SWIG_IsOK(ecode2)) {
24341 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
24342 }
24343 arg2 = static_cast< bool >(val2);
24344 if (arg1) (arg1)->m_controlDown = arg2;
24345
24346 resultobj = SWIG_Py_Void();
24347 return resultobj;
24348 fail:
24349 return NULL;
24350 }
24351
24352
24353 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24354 PyObject *resultobj = 0;
24355 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24356 bool result;
24357 void *argp1 = 0 ;
24358 int res1 = 0 ;
24359 PyObject *swig_obj[1] ;
24360
24361 if (!args) SWIG_fail;
24362 swig_obj[0] = args;
24363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24364 if (!SWIG_IsOK(res1)) {
24365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24366 }
24367 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24368 result = (bool) ((arg1)->m_controlDown);
24369 {
24370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24371 }
24372 return resultobj;
24373 fail:
24374 return NULL;
24375 }
24376
24377
24378 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24379 PyObject *resultobj = 0;
24380 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24381 bool arg2 ;
24382 void *argp1 = 0 ;
24383 int res1 = 0 ;
24384 bool val2 ;
24385 int ecode2 = 0 ;
24386 PyObject *swig_obj[2] ;
24387
24388 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
24389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24390 if (!SWIG_IsOK(res1)) {
24391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24392 }
24393 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24394 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24395 if (!SWIG_IsOK(ecode2)) {
24396 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
24397 }
24398 arg2 = static_cast< bool >(val2);
24399 if (arg1) (arg1)->m_shiftDown = arg2;
24400
24401 resultobj = SWIG_Py_Void();
24402 return resultobj;
24403 fail:
24404 return NULL;
24405 }
24406
24407
24408 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24409 PyObject *resultobj = 0;
24410 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24411 bool result;
24412 void *argp1 = 0 ;
24413 int res1 = 0 ;
24414 PyObject *swig_obj[1] ;
24415
24416 if (!args) SWIG_fail;
24417 swig_obj[0] = args;
24418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24419 if (!SWIG_IsOK(res1)) {
24420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24421 }
24422 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24423 result = (bool) ((arg1)->m_shiftDown);
24424 {
24425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24426 }
24427 return resultobj;
24428 fail:
24429 return NULL;
24430 }
24431
24432
24433 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24434 PyObject *resultobj = 0;
24435 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24436 bool arg2 ;
24437 void *argp1 = 0 ;
24438 int res1 = 0 ;
24439 bool val2 ;
24440 int ecode2 = 0 ;
24441 PyObject *swig_obj[2] ;
24442
24443 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
24444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24445 if (!SWIG_IsOK(res1)) {
24446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24447 }
24448 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24449 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24450 if (!SWIG_IsOK(ecode2)) {
24451 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
24452 }
24453 arg2 = static_cast< bool >(val2);
24454 if (arg1) (arg1)->m_altDown = arg2;
24455
24456 resultobj = SWIG_Py_Void();
24457 return resultobj;
24458 fail:
24459 return NULL;
24460 }
24461
24462
24463 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24464 PyObject *resultobj = 0;
24465 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24466 bool result;
24467 void *argp1 = 0 ;
24468 int res1 = 0 ;
24469 PyObject *swig_obj[1] ;
24470
24471 if (!args) SWIG_fail;
24472 swig_obj[0] = args;
24473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24474 if (!SWIG_IsOK(res1)) {
24475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24476 }
24477 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24478 result = (bool) ((arg1)->m_altDown);
24479 {
24480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24481 }
24482 return resultobj;
24483 fail:
24484 return NULL;
24485 }
24486
24487
24488 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24489 PyObject *resultobj = 0;
24490 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24491 bool arg2 ;
24492 void *argp1 = 0 ;
24493 int res1 = 0 ;
24494 bool val2 ;
24495 int ecode2 = 0 ;
24496 PyObject *swig_obj[2] ;
24497
24498 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
24499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24500 if (!SWIG_IsOK(res1)) {
24501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24502 }
24503 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24504 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24505 if (!SWIG_IsOK(ecode2)) {
24506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
24507 }
24508 arg2 = static_cast< bool >(val2);
24509 if (arg1) (arg1)->m_metaDown = arg2;
24510
24511 resultobj = SWIG_Py_Void();
24512 return resultobj;
24513 fail:
24514 return NULL;
24515 }
24516
24517
24518 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24519 PyObject *resultobj = 0;
24520 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24521 bool result;
24522 void *argp1 = 0 ;
24523 int res1 = 0 ;
24524 PyObject *swig_obj[1] ;
24525
24526 if (!args) SWIG_fail;
24527 swig_obj[0] = args;
24528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24529 if (!SWIG_IsOK(res1)) {
24530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24531 }
24532 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24533 result = (bool) ((arg1)->m_metaDown);
24534 {
24535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24536 }
24537 return resultobj;
24538 fail:
24539 return NULL;
24540 }
24541
24542
24543 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24544 PyObject *resultobj = 0;
24545 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24546 int arg2 ;
24547 void *argp1 = 0 ;
24548 int res1 = 0 ;
24549 int val2 ;
24550 int ecode2 = 0 ;
24551 PyObject *swig_obj[2] ;
24552
24553 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
24554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24555 if (!SWIG_IsOK(res1)) {
24556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24557 }
24558 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24559 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24560 if (!SWIG_IsOK(ecode2)) {
24561 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
24562 }
24563 arg2 = static_cast< int >(val2);
24564 if (arg1) (arg1)->m_wheelRotation = arg2;
24565
24566 resultobj = SWIG_Py_Void();
24567 return resultobj;
24568 fail:
24569 return NULL;
24570 }
24571
24572
24573 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24574 PyObject *resultobj = 0;
24575 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24576 int result;
24577 void *argp1 = 0 ;
24578 int res1 = 0 ;
24579 PyObject *swig_obj[1] ;
24580
24581 if (!args) SWIG_fail;
24582 swig_obj[0] = args;
24583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24584 if (!SWIG_IsOK(res1)) {
24585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24586 }
24587 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24588 result = (int) ((arg1)->m_wheelRotation);
24589 resultobj = SWIG_From_int(static_cast< int >(result));
24590 return resultobj;
24591 fail:
24592 return NULL;
24593 }
24594
24595
24596 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24597 PyObject *resultobj = 0;
24598 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24599 int arg2 ;
24600 void *argp1 = 0 ;
24601 int res1 = 0 ;
24602 int val2 ;
24603 int ecode2 = 0 ;
24604 PyObject *swig_obj[2] ;
24605
24606 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
24607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24608 if (!SWIG_IsOK(res1)) {
24609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24610 }
24611 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24612 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24613 if (!SWIG_IsOK(ecode2)) {
24614 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
24615 }
24616 arg2 = static_cast< int >(val2);
24617 if (arg1) (arg1)->m_wheelDelta = arg2;
24618
24619 resultobj = SWIG_Py_Void();
24620 return resultobj;
24621 fail:
24622 return NULL;
24623 }
24624
24625
24626 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24627 PyObject *resultobj = 0;
24628 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24629 int result;
24630 void *argp1 = 0 ;
24631 int res1 = 0 ;
24632 PyObject *swig_obj[1] ;
24633
24634 if (!args) SWIG_fail;
24635 swig_obj[0] = args;
24636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24637 if (!SWIG_IsOK(res1)) {
24638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24639 }
24640 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24641 result = (int) ((arg1)->m_wheelDelta);
24642 resultobj = SWIG_From_int(static_cast< int >(result));
24643 return resultobj;
24644 fail:
24645 return NULL;
24646 }
24647
24648
24649 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24650 PyObject *resultobj = 0;
24651 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24652 int arg2 ;
24653 void *argp1 = 0 ;
24654 int res1 = 0 ;
24655 int val2 ;
24656 int ecode2 = 0 ;
24657 PyObject *swig_obj[2] ;
24658
24659 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
24660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24661 if (!SWIG_IsOK(res1)) {
24662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24663 }
24664 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24665 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24666 if (!SWIG_IsOK(ecode2)) {
24667 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
24668 }
24669 arg2 = static_cast< int >(val2);
24670 if (arg1) (arg1)->m_linesPerAction = arg2;
24671
24672 resultobj = SWIG_Py_Void();
24673 return resultobj;
24674 fail:
24675 return NULL;
24676 }
24677
24678
24679 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24680 PyObject *resultobj = 0;
24681 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24682 int result;
24683 void *argp1 = 0 ;
24684 int res1 = 0 ;
24685 PyObject *swig_obj[1] ;
24686
24687 if (!args) SWIG_fail;
24688 swig_obj[0] = args;
24689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24690 if (!SWIG_IsOK(res1)) {
24691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24692 }
24693 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24694 result = (int) ((arg1)->m_linesPerAction);
24695 resultobj = SWIG_From_int(static_cast< int >(result));
24696 return resultobj;
24697 fail:
24698 return NULL;
24699 }
24700
24701
24702 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24703 PyObject *obj;
24704 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24705 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
24706 return SWIG_Py_Void();
24707 }
24708
24709 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24710 return SWIG_Python_InitShadowInstance(args);
24711 }
24712
24713 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24714 PyObject *resultobj = 0;
24715 int arg1 = (int) 0 ;
24716 int arg2 = (int) 0 ;
24717 wxSetCursorEvent *result = 0 ;
24718 int val1 ;
24719 int ecode1 = 0 ;
24720 int val2 ;
24721 int ecode2 = 0 ;
24722 PyObject * obj0 = 0 ;
24723 PyObject * obj1 = 0 ;
24724 char * kwnames[] = {
24725 (char *) "x",(char *) "y", NULL
24726 };
24727
24728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24729 if (obj0) {
24730 ecode1 = SWIG_AsVal_int(obj0, &val1);
24731 if (!SWIG_IsOK(ecode1)) {
24732 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
24733 }
24734 arg1 = static_cast< int >(val1);
24735 }
24736 if (obj1) {
24737 ecode2 = SWIG_AsVal_int(obj1, &val2);
24738 if (!SWIG_IsOK(ecode2)) {
24739 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
24740 }
24741 arg2 = static_cast< int >(val2);
24742 }
24743 {
24744 PyThreadState* __tstate = wxPyBeginAllowThreads();
24745 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
24746 wxPyEndAllowThreads(__tstate);
24747 if (PyErr_Occurred()) SWIG_fail;
24748 }
24749 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
24750 return resultobj;
24751 fail:
24752 return NULL;
24753 }
24754
24755
24756 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24757 PyObject *resultobj = 0;
24758 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24759 int result;
24760 void *argp1 = 0 ;
24761 int res1 = 0 ;
24762 PyObject *swig_obj[1] ;
24763
24764 if (!args) SWIG_fail;
24765 swig_obj[0] = args;
24766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24767 if (!SWIG_IsOK(res1)) {
24768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24769 }
24770 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24771 {
24772 PyThreadState* __tstate = wxPyBeginAllowThreads();
24773 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
24774 wxPyEndAllowThreads(__tstate);
24775 if (PyErr_Occurred()) SWIG_fail;
24776 }
24777 resultobj = SWIG_From_int(static_cast< int >(result));
24778 return resultobj;
24779 fail:
24780 return NULL;
24781 }
24782
24783
24784 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24785 PyObject *resultobj = 0;
24786 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24787 int result;
24788 void *argp1 = 0 ;
24789 int res1 = 0 ;
24790 PyObject *swig_obj[1] ;
24791
24792 if (!args) SWIG_fail;
24793 swig_obj[0] = args;
24794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24795 if (!SWIG_IsOK(res1)) {
24796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24797 }
24798 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24799 {
24800 PyThreadState* __tstate = wxPyBeginAllowThreads();
24801 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
24802 wxPyEndAllowThreads(__tstate);
24803 if (PyErr_Occurred()) SWIG_fail;
24804 }
24805 resultobj = SWIG_From_int(static_cast< int >(result));
24806 return resultobj;
24807 fail:
24808 return NULL;
24809 }
24810
24811
24812 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24813 PyObject *resultobj = 0;
24814 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24815 wxCursor *arg2 = 0 ;
24816 void *argp1 = 0 ;
24817 int res1 = 0 ;
24818 void *argp2 = 0 ;
24819 int res2 = 0 ;
24820 PyObject * obj0 = 0 ;
24821 PyObject * obj1 = 0 ;
24822 char * kwnames[] = {
24823 (char *) "self",(char *) "cursor", NULL
24824 };
24825
24826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
24827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24828 if (!SWIG_IsOK(res1)) {
24829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
24830 }
24831 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24832 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
24833 if (!SWIG_IsOK(res2)) {
24834 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
24835 }
24836 if (!argp2) {
24837 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
24838 }
24839 arg2 = reinterpret_cast< wxCursor * >(argp2);
24840 {
24841 PyThreadState* __tstate = wxPyBeginAllowThreads();
24842 (arg1)->SetCursor((wxCursor const &)*arg2);
24843 wxPyEndAllowThreads(__tstate);
24844 if (PyErr_Occurred()) SWIG_fail;
24845 }
24846 resultobj = SWIG_Py_Void();
24847 return resultobj;
24848 fail:
24849 return NULL;
24850 }
24851
24852
24853 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24854 PyObject *resultobj = 0;
24855 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24856 wxCursor *result = 0 ;
24857 void *argp1 = 0 ;
24858 int res1 = 0 ;
24859 PyObject *swig_obj[1] ;
24860
24861 if (!args) SWIG_fail;
24862 swig_obj[0] = args;
24863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24864 if (!SWIG_IsOK(res1)) {
24865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24866 }
24867 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24868 {
24869 PyThreadState* __tstate = wxPyBeginAllowThreads();
24870 {
24871 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
24872 result = (wxCursor *) &_result_ref;
24873 }
24874 wxPyEndAllowThreads(__tstate);
24875 if (PyErr_Occurred()) SWIG_fail;
24876 }
24877 {
24878 wxCursor* resultptr = new wxCursor(*result);
24879 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
24880 }
24881 return resultobj;
24882 fail:
24883 return NULL;
24884 }
24885
24886
24887 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24888 PyObject *resultobj = 0;
24889 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24890 bool result;
24891 void *argp1 = 0 ;
24892 int res1 = 0 ;
24893 PyObject *swig_obj[1] ;
24894
24895 if (!args) SWIG_fail;
24896 swig_obj[0] = args;
24897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24898 if (!SWIG_IsOK(res1)) {
24899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24900 }
24901 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24902 {
24903 PyThreadState* __tstate = wxPyBeginAllowThreads();
24904 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
24905 wxPyEndAllowThreads(__tstate);
24906 if (PyErr_Occurred()) SWIG_fail;
24907 }
24908 {
24909 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24910 }
24911 return resultobj;
24912 fail:
24913 return NULL;
24914 }
24915
24916
24917 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24918 PyObject *obj;
24919 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24920 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
24921 return SWIG_Py_Void();
24922 }
24923
24924 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24925 return SWIG_Python_InitShadowInstance(args);
24926 }
24927
24928 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24929 PyObject *resultobj = 0;
24930 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24931 wxKeyEvent *result = 0 ;
24932 int val1 ;
24933 int ecode1 = 0 ;
24934 PyObject * obj0 = 0 ;
24935 char * kwnames[] = {
24936 (char *) "eventType", NULL
24937 };
24938
24939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
24940 if (obj0) {
24941 ecode1 = SWIG_AsVal_int(obj0, &val1);
24942 if (!SWIG_IsOK(ecode1)) {
24943 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24944 }
24945 arg1 = static_cast< wxEventType >(val1);
24946 }
24947 {
24948 PyThreadState* __tstate = wxPyBeginAllowThreads();
24949 result = (wxKeyEvent *)new wxKeyEvent(arg1);
24950 wxPyEndAllowThreads(__tstate);
24951 if (PyErr_Occurred()) SWIG_fail;
24952 }
24953 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
24954 return resultobj;
24955 fail:
24956 return NULL;
24957 }
24958
24959
24960 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24961 PyObject *resultobj = 0;
24962 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24963 int result;
24964 void *argp1 = 0 ;
24965 int res1 = 0 ;
24966 PyObject *swig_obj[1] ;
24967
24968 if (!args) SWIG_fail;
24969 swig_obj[0] = args;
24970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24971 if (!SWIG_IsOK(res1)) {
24972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24973 }
24974 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24975 {
24976 PyThreadState* __tstate = wxPyBeginAllowThreads();
24977 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
24978 wxPyEndAllowThreads(__tstate);
24979 if (PyErr_Occurred()) SWIG_fail;
24980 }
24981 resultobj = SWIG_From_int(static_cast< int >(result));
24982 return resultobj;
24983 fail:
24984 return NULL;
24985 }
24986
24987
24988 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24989 PyObject *resultobj = 0;
24990 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24991 bool result;
24992 void *argp1 = 0 ;
24993 int res1 = 0 ;
24994 PyObject *swig_obj[1] ;
24995
24996 if (!args) SWIG_fail;
24997 swig_obj[0] = args;
24998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24999 if (!SWIG_IsOK(res1)) {
25000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25001 }
25002 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25003 {
25004 PyThreadState* __tstate = wxPyBeginAllowThreads();
25005 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
25006 wxPyEndAllowThreads(__tstate);
25007 if (PyErr_Occurred()) SWIG_fail;
25008 }
25009 {
25010 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25011 }
25012 return resultobj;
25013 fail:
25014 return NULL;
25015 }
25016
25017
25018 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25019 PyObject *resultobj = 0;
25020 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25021 bool result;
25022 void *argp1 = 0 ;
25023 int res1 = 0 ;
25024 PyObject *swig_obj[1] ;
25025
25026 if (!args) SWIG_fail;
25027 swig_obj[0] = args;
25028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25029 if (!SWIG_IsOK(res1)) {
25030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25031 }
25032 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25033 {
25034 PyThreadState* __tstate = wxPyBeginAllowThreads();
25035 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
25036 wxPyEndAllowThreads(__tstate);
25037 if (PyErr_Occurred()) SWIG_fail;
25038 }
25039 {
25040 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25041 }
25042 return resultobj;
25043 fail:
25044 return NULL;
25045 }
25046
25047
25048 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25049 PyObject *resultobj = 0;
25050 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25051 bool result;
25052 void *argp1 = 0 ;
25053 int res1 = 0 ;
25054 PyObject *swig_obj[1] ;
25055
25056 if (!args) SWIG_fail;
25057 swig_obj[0] = args;
25058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25059 if (!SWIG_IsOK(res1)) {
25060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25061 }
25062 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25063 {
25064 PyThreadState* __tstate = wxPyBeginAllowThreads();
25065 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
25066 wxPyEndAllowThreads(__tstate);
25067 if (PyErr_Occurred()) SWIG_fail;
25068 }
25069 {
25070 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25071 }
25072 return resultobj;
25073 fail:
25074 return NULL;
25075 }
25076
25077
25078 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25079 PyObject *resultobj = 0;
25080 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25081 bool result;
25082 void *argp1 = 0 ;
25083 int res1 = 0 ;
25084 PyObject *swig_obj[1] ;
25085
25086 if (!args) SWIG_fail;
25087 swig_obj[0] = args;
25088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25089 if (!SWIG_IsOK(res1)) {
25090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25091 }
25092 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25093 {
25094 PyThreadState* __tstate = wxPyBeginAllowThreads();
25095 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
25096 wxPyEndAllowThreads(__tstate);
25097 if (PyErr_Occurred()) SWIG_fail;
25098 }
25099 {
25100 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25101 }
25102 return resultobj;
25103 fail:
25104 return NULL;
25105 }
25106
25107
25108 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25109 PyObject *resultobj = 0;
25110 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25111 bool result;
25112 void *argp1 = 0 ;
25113 int res1 = 0 ;
25114 PyObject *swig_obj[1] ;
25115
25116 if (!args) SWIG_fail;
25117 swig_obj[0] = args;
25118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25119 if (!SWIG_IsOK(res1)) {
25120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25121 }
25122 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25123 {
25124 PyThreadState* __tstate = wxPyBeginAllowThreads();
25125 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
25126 wxPyEndAllowThreads(__tstate);
25127 if (PyErr_Occurred()) SWIG_fail;
25128 }
25129 {
25130 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25131 }
25132 return resultobj;
25133 fail:
25134 return NULL;
25135 }
25136
25137
25138 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25139 PyObject *resultobj = 0;
25140 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25141 bool result;
25142 void *argp1 = 0 ;
25143 int res1 = 0 ;
25144 PyObject *swig_obj[1] ;
25145
25146 if (!args) SWIG_fail;
25147 swig_obj[0] = args;
25148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25149 if (!SWIG_IsOK(res1)) {
25150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25151 }
25152 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25153 {
25154 PyThreadState* __tstate = wxPyBeginAllowThreads();
25155 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
25156 wxPyEndAllowThreads(__tstate);
25157 if (PyErr_Occurred()) SWIG_fail;
25158 }
25159 {
25160 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25161 }
25162 return resultobj;
25163 fail:
25164 return NULL;
25165 }
25166
25167
25168 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25169 PyObject *resultobj = 0;
25170 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25171 int result;
25172 void *argp1 = 0 ;
25173 int res1 = 0 ;
25174 PyObject *swig_obj[1] ;
25175
25176 if (!args) SWIG_fail;
25177 swig_obj[0] = args;
25178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25179 if (!SWIG_IsOK(res1)) {
25180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25181 }
25182 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25183 {
25184 PyThreadState* __tstate = wxPyBeginAllowThreads();
25185 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
25186 wxPyEndAllowThreads(__tstate);
25187 if (PyErr_Occurred()) SWIG_fail;
25188 }
25189 resultobj = SWIG_From_int(static_cast< int >(result));
25190 return resultobj;
25191 fail:
25192 return NULL;
25193 }
25194
25195
25196 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25197 PyObject *resultobj = 0;
25198 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25199 int result;
25200 void *argp1 = 0 ;
25201 int res1 = 0 ;
25202 PyObject *swig_obj[1] ;
25203
25204 if (!args) SWIG_fail;
25205 swig_obj[0] = args;
25206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25207 if (!SWIG_IsOK(res1)) {
25208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25209 }
25210 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25211 {
25212 PyThreadState* __tstate = wxPyBeginAllowThreads();
25213 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
25214 wxPyEndAllowThreads(__tstate);
25215 if (PyErr_Occurred()) SWIG_fail;
25216 }
25217 resultobj = SWIG_From_int(static_cast< int >(result));
25218 return resultobj;
25219 fail:
25220 return NULL;
25221 }
25222
25223
25224 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25225 PyObject *resultobj = 0;
25226 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25227 int arg2 ;
25228 void *argp1 = 0 ;
25229 int res1 = 0 ;
25230 int val2 ;
25231 int ecode2 = 0 ;
25232 PyObject * obj0 = 0 ;
25233 PyObject * obj1 = 0 ;
25234 char * kwnames[] = {
25235 (char *) "self",(char *) "uniChar", NULL
25236 };
25237
25238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
25239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25240 if (!SWIG_IsOK(res1)) {
25241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25242 }
25243 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25244 ecode2 = SWIG_AsVal_int(obj1, &val2);
25245 if (!SWIG_IsOK(ecode2)) {
25246 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
25247 }
25248 arg2 = static_cast< int >(val2);
25249 {
25250 PyThreadState* __tstate = wxPyBeginAllowThreads();
25251 wxKeyEvent_SetUnicodeKey(arg1,arg2);
25252 wxPyEndAllowThreads(__tstate);
25253 if (PyErr_Occurred()) SWIG_fail;
25254 }
25255 resultobj = SWIG_Py_Void();
25256 return resultobj;
25257 fail:
25258 return NULL;
25259 }
25260
25261
25262 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25263 PyObject *resultobj = 0;
25264 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25265 unsigned int result;
25266 void *argp1 = 0 ;
25267 int res1 = 0 ;
25268 PyObject *swig_obj[1] ;
25269
25270 if (!args) SWIG_fail;
25271 swig_obj[0] = args;
25272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25273 if (!SWIG_IsOK(res1)) {
25274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25275 }
25276 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25277 {
25278 PyThreadState* __tstate = wxPyBeginAllowThreads();
25279 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
25280 wxPyEndAllowThreads(__tstate);
25281 if (PyErr_Occurred()) SWIG_fail;
25282 }
25283 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25284 return resultobj;
25285 fail:
25286 return NULL;
25287 }
25288
25289
25290 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25291 PyObject *resultobj = 0;
25292 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25293 unsigned int result;
25294 void *argp1 = 0 ;
25295 int res1 = 0 ;
25296 PyObject *swig_obj[1] ;
25297
25298 if (!args) SWIG_fail;
25299 swig_obj[0] = args;
25300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25301 if (!SWIG_IsOK(res1)) {
25302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25303 }
25304 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25305 {
25306 PyThreadState* __tstate = wxPyBeginAllowThreads();
25307 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
25308 wxPyEndAllowThreads(__tstate);
25309 if (PyErr_Occurred()) SWIG_fail;
25310 }
25311 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25312 return resultobj;
25313 fail:
25314 return NULL;
25315 }
25316
25317
25318 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25319 PyObject *resultobj = 0;
25320 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25321 wxPoint result;
25322 void *argp1 = 0 ;
25323 int res1 = 0 ;
25324 PyObject *swig_obj[1] ;
25325
25326 if (!args) SWIG_fail;
25327 swig_obj[0] = args;
25328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25329 if (!SWIG_IsOK(res1)) {
25330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25331 }
25332 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25333 {
25334 PyThreadState* __tstate = wxPyBeginAllowThreads();
25335 result = (arg1)->GetPosition();
25336 wxPyEndAllowThreads(__tstate);
25337 if (PyErr_Occurred()) SWIG_fail;
25338 }
25339 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
25340 return resultobj;
25341 fail:
25342 return NULL;
25343 }
25344
25345
25346 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25347 PyObject *resultobj = 0;
25348 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25349 long *arg2 = (long *) 0 ;
25350 long *arg3 = (long *) 0 ;
25351 void *argp1 = 0 ;
25352 int res1 = 0 ;
25353 long temp2 ;
25354 int res2 = SWIG_TMPOBJ ;
25355 long temp3 ;
25356 int res3 = SWIG_TMPOBJ ;
25357 PyObject *swig_obj[1] ;
25358
25359 arg2 = &temp2;
25360 arg3 = &temp3;
25361 if (!args) SWIG_fail;
25362 swig_obj[0] = args;
25363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25364 if (!SWIG_IsOK(res1)) {
25365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25366 }
25367 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25368 {
25369 PyThreadState* __tstate = wxPyBeginAllowThreads();
25370 (arg1)->GetPosition(arg2,arg3);
25371 wxPyEndAllowThreads(__tstate);
25372 if (PyErr_Occurred()) SWIG_fail;
25373 }
25374 resultobj = SWIG_Py_Void();
25375 if (SWIG_IsTmpObj(res2)) {
25376 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
25377 } else {
25378 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25379 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
25380 }
25381 if (SWIG_IsTmpObj(res3)) {
25382 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
25383 } else {
25384 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25385 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
25386 }
25387 return resultobj;
25388 fail:
25389 return NULL;
25390 }
25391
25392
25393 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25394 PyObject *resultobj = 0;
25395 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25396 int result;
25397 void *argp1 = 0 ;
25398 int res1 = 0 ;
25399 PyObject *swig_obj[1] ;
25400
25401 if (!args) SWIG_fail;
25402 swig_obj[0] = args;
25403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25404 if (!SWIG_IsOK(res1)) {
25405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25406 }
25407 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25408 {
25409 PyThreadState* __tstate = wxPyBeginAllowThreads();
25410 result = (int)((wxKeyEvent const *)arg1)->GetX();
25411 wxPyEndAllowThreads(__tstate);
25412 if (PyErr_Occurred()) SWIG_fail;
25413 }
25414 resultobj = SWIG_From_int(static_cast< int >(result));
25415 return resultobj;
25416 fail:
25417 return NULL;
25418 }
25419
25420
25421 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25422 PyObject *resultobj = 0;
25423 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25424 int result;
25425 void *argp1 = 0 ;
25426 int res1 = 0 ;
25427 PyObject *swig_obj[1] ;
25428
25429 if (!args) SWIG_fail;
25430 swig_obj[0] = args;
25431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25432 if (!SWIG_IsOK(res1)) {
25433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25434 }
25435 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25436 {
25437 PyThreadState* __tstate = wxPyBeginAllowThreads();
25438 result = (int)((wxKeyEvent const *)arg1)->GetY();
25439 wxPyEndAllowThreads(__tstate);
25440 if (PyErr_Occurred()) SWIG_fail;
25441 }
25442 resultobj = SWIG_From_int(static_cast< int >(result));
25443 return resultobj;
25444 fail:
25445 return NULL;
25446 }
25447
25448
25449 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25450 PyObject *resultobj = 0;
25451 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25452 int arg2 ;
25453 void *argp1 = 0 ;
25454 int res1 = 0 ;
25455 int val2 ;
25456 int ecode2 = 0 ;
25457 PyObject *swig_obj[2] ;
25458
25459 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
25460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25461 if (!SWIG_IsOK(res1)) {
25462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25463 }
25464 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25465 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25466 if (!SWIG_IsOK(ecode2)) {
25467 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
25468 }
25469 arg2 = static_cast< int >(val2);
25470 if (arg1) (arg1)->m_x = arg2;
25471
25472 resultobj = SWIG_Py_Void();
25473 return resultobj;
25474 fail:
25475 return NULL;
25476 }
25477
25478
25479 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25480 PyObject *resultobj = 0;
25481 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25482 int result;
25483 void *argp1 = 0 ;
25484 int res1 = 0 ;
25485 PyObject *swig_obj[1] ;
25486
25487 if (!args) SWIG_fail;
25488 swig_obj[0] = args;
25489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25490 if (!SWIG_IsOK(res1)) {
25491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25492 }
25493 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25494 result = (int) ((arg1)->m_x);
25495 resultobj = SWIG_From_int(static_cast< int >(result));
25496 return resultobj;
25497 fail:
25498 return NULL;
25499 }
25500
25501
25502 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25503 PyObject *resultobj = 0;
25504 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25505 int arg2 ;
25506 void *argp1 = 0 ;
25507 int res1 = 0 ;
25508 int val2 ;
25509 int ecode2 = 0 ;
25510 PyObject *swig_obj[2] ;
25511
25512 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
25513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25514 if (!SWIG_IsOK(res1)) {
25515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25516 }
25517 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25518 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25519 if (!SWIG_IsOK(ecode2)) {
25520 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
25521 }
25522 arg2 = static_cast< int >(val2);
25523 if (arg1) (arg1)->m_y = arg2;
25524
25525 resultobj = SWIG_Py_Void();
25526 return resultobj;
25527 fail:
25528 return NULL;
25529 }
25530
25531
25532 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25533 PyObject *resultobj = 0;
25534 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25535 int result;
25536 void *argp1 = 0 ;
25537 int res1 = 0 ;
25538 PyObject *swig_obj[1] ;
25539
25540 if (!args) SWIG_fail;
25541 swig_obj[0] = args;
25542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25543 if (!SWIG_IsOK(res1)) {
25544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25545 }
25546 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25547 result = (int) ((arg1)->m_y);
25548 resultobj = SWIG_From_int(static_cast< int >(result));
25549 return resultobj;
25550 fail:
25551 return NULL;
25552 }
25553
25554
25555 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25556 PyObject *resultobj = 0;
25557 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25558 long arg2 ;
25559 void *argp1 = 0 ;
25560 int res1 = 0 ;
25561 long val2 ;
25562 int ecode2 = 0 ;
25563 PyObject *swig_obj[2] ;
25564
25565 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
25566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25567 if (!SWIG_IsOK(res1)) {
25568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25569 }
25570 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25571 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
25572 if (!SWIG_IsOK(ecode2)) {
25573 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
25574 }
25575 arg2 = static_cast< long >(val2);
25576 if (arg1) (arg1)->m_keyCode = arg2;
25577
25578 resultobj = SWIG_Py_Void();
25579 return resultobj;
25580 fail:
25581 return NULL;
25582 }
25583
25584
25585 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25586 PyObject *resultobj = 0;
25587 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25588 long result;
25589 void *argp1 = 0 ;
25590 int res1 = 0 ;
25591 PyObject *swig_obj[1] ;
25592
25593 if (!args) SWIG_fail;
25594 swig_obj[0] = args;
25595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25596 if (!SWIG_IsOK(res1)) {
25597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25598 }
25599 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25600 result = (long) ((arg1)->m_keyCode);
25601 resultobj = SWIG_From_long(static_cast< long >(result));
25602 return resultobj;
25603 fail:
25604 return NULL;
25605 }
25606
25607
25608 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25609 PyObject *resultobj = 0;
25610 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25611 bool arg2 ;
25612 void *argp1 = 0 ;
25613 int res1 = 0 ;
25614 bool val2 ;
25615 int ecode2 = 0 ;
25616 PyObject *swig_obj[2] ;
25617
25618 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
25619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25620 if (!SWIG_IsOK(res1)) {
25621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25622 }
25623 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25624 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25625 if (!SWIG_IsOK(ecode2)) {
25626 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
25627 }
25628 arg2 = static_cast< bool >(val2);
25629 if (arg1) (arg1)->m_controlDown = arg2;
25630
25631 resultobj = SWIG_Py_Void();
25632 return resultobj;
25633 fail:
25634 return NULL;
25635 }
25636
25637
25638 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25639 PyObject *resultobj = 0;
25640 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25641 bool result;
25642 void *argp1 = 0 ;
25643 int res1 = 0 ;
25644 PyObject *swig_obj[1] ;
25645
25646 if (!args) SWIG_fail;
25647 swig_obj[0] = args;
25648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25649 if (!SWIG_IsOK(res1)) {
25650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25651 }
25652 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25653 result = (bool) ((arg1)->m_controlDown);
25654 {
25655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25656 }
25657 return resultobj;
25658 fail:
25659 return NULL;
25660 }
25661
25662
25663 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25664 PyObject *resultobj = 0;
25665 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25666 bool arg2 ;
25667 void *argp1 = 0 ;
25668 int res1 = 0 ;
25669 bool val2 ;
25670 int ecode2 = 0 ;
25671 PyObject *swig_obj[2] ;
25672
25673 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
25674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25675 if (!SWIG_IsOK(res1)) {
25676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25677 }
25678 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25679 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25680 if (!SWIG_IsOK(ecode2)) {
25681 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
25682 }
25683 arg2 = static_cast< bool >(val2);
25684 if (arg1) (arg1)->m_shiftDown = arg2;
25685
25686 resultobj = SWIG_Py_Void();
25687 return resultobj;
25688 fail:
25689 return NULL;
25690 }
25691
25692
25693 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25694 PyObject *resultobj = 0;
25695 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25696 bool result;
25697 void *argp1 = 0 ;
25698 int res1 = 0 ;
25699 PyObject *swig_obj[1] ;
25700
25701 if (!args) SWIG_fail;
25702 swig_obj[0] = args;
25703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25704 if (!SWIG_IsOK(res1)) {
25705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25706 }
25707 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25708 result = (bool) ((arg1)->m_shiftDown);
25709 {
25710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25711 }
25712 return resultobj;
25713 fail:
25714 return NULL;
25715 }
25716
25717
25718 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25719 PyObject *resultobj = 0;
25720 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25721 bool arg2 ;
25722 void *argp1 = 0 ;
25723 int res1 = 0 ;
25724 bool val2 ;
25725 int ecode2 = 0 ;
25726 PyObject *swig_obj[2] ;
25727
25728 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
25729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25730 if (!SWIG_IsOK(res1)) {
25731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25732 }
25733 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25734 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25735 if (!SWIG_IsOK(ecode2)) {
25736 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
25737 }
25738 arg2 = static_cast< bool >(val2);
25739 if (arg1) (arg1)->m_altDown = arg2;
25740
25741 resultobj = SWIG_Py_Void();
25742 return resultobj;
25743 fail:
25744 return NULL;
25745 }
25746
25747
25748 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25749 PyObject *resultobj = 0;
25750 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25751 bool result;
25752 void *argp1 = 0 ;
25753 int res1 = 0 ;
25754 PyObject *swig_obj[1] ;
25755
25756 if (!args) SWIG_fail;
25757 swig_obj[0] = args;
25758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25759 if (!SWIG_IsOK(res1)) {
25760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25761 }
25762 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25763 result = (bool) ((arg1)->m_altDown);
25764 {
25765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25766 }
25767 return resultobj;
25768 fail:
25769 return NULL;
25770 }
25771
25772
25773 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25774 PyObject *resultobj = 0;
25775 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25776 bool arg2 ;
25777 void *argp1 = 0 ;
25778 int res1 = 0 ;
25779 bool val2 ;
25780 int ecode2 = 0 ;
25781 PyObject *swig_obj[2] ;
25782
25783 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
25784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25785 if (!SWIG_IsOK(res1)) {
25786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25787 }
25788 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25789 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25790 if (!SWIG_IsOK(ecode2)) {
25791 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
25792 }
25793 arg2 = static_cast< bool >(val2);
25794 if (arg1) (arg1)->m_metaDown = arg2;
25795
25796 resultobj = SWIG_Py_Void();
25797 return resultobj;
25798 fail:
25799 return NULL;
25800 }
25801
25802
25803 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25804 PyObject *resultobj = 0;
25805 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25806 bool result;
25807 void *argp1 = 0 ;
25808 int res1 = 0 ;
25809 PyObject *swig_obj[1] ;
25810
25811 if (!args) SWIG_fail;
25812 swig_obj[0] = args;
25813 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25814 if (!SWIG_IsOK(res1)) {
25815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25816 }
25817 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25818 result = (bool) ((arg1)->m_metaDown);
25819 {
25820 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25821 }
25822 return resultobj;
25823 fail:
25824 return NULL;
25825 }
25826
25827
25828 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25829 PyObject *resultobj = 0;
25830 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25831 bool arg2 ;
25832 void *argp1 = 0 ;
25833 int res1 = 0 ;
25834 bool val2 ;
25835 int ecode2 = 0 ;
25836 PyObject *swig_obj[2] ;
25837
25838 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
25839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25840 if (!SWIG_IsOK(res1)) {
25841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25842 }
25843 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25844 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25845 if (!SWIG_IsOK(ecode2)) {
25846 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
25847 }
25848 arg2 = static_cast< bool >(val2);
25849 if (arg1) (arg1)->m_scanCode = arg2;
25850
25851 resultobj = SWIG_Py_Void();
25852 return resultobj;
25853 fail:
25854 return NULL;
25855 }
25856
25857
25858 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25859 PyObject *resultobj = 0;
25860 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25861 bool result;
25862 void *argp1 = 0 ;
25863 int res1 = 0 ;
25864 PyObject *swig_obj[1] ;
25865
25866 if (!args) SWIG_fail;
25867 swig_obj[0] = args;
25868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25869 if (!SWIG_IsOK(res1)) {
25870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25871 }
25872 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25873 result = (bool) ((arg1)->m_scanCode);
25874 {
25875 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25876 }
25877 return resultobj;
25878 fail:
25879 return NULL;
25880 }
25881
25882
25883 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25884 PyObject *resultobj = 0;
25885 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25886 unsigned int arg2 ;
25887 void *argp1 = 0 ;
25888 int res1 = 0 ;
25889 unsigned int val2 ;
25890 int ecode2 = 0 ;
25891 PyObject *swig_obj[2] ;
25892
25893 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
25894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25895 if (!SWIG_IsOK(res1)) {
25896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25897 }
25898 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25899 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
25900 if (!SWIG_IsOK(ecode2)) {
25901 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
25902 }
25903 arg2 = static_cast< unsigned int >(val2);
25904 if (arg1) (arg1)->m_rawCode = arg2;
25905
25906 resultobj = SWIG_Py_Void();
25907 return resultobj;
25908 fail:
25909 return NULL;
25910 }
25911
25912
25913 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25914 PyObject *resultobj = 0;
25915 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25916 unsigned int result;
25917 void *argp1 = 0 ;
25918 int res1 = 0 ;
25919 PyObject *swig_obj[1] ;
25920
25921 if (!args) SWIG_fail;
25922 swig_obj[0] = args;
25923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25924 if (!SWIG_IsOK(res1)) {
25925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25926 }
25927 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25928 result = (unsigned int) ((arg1)->m_rawCode);
25929 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25930 return resultobj;
25931 fail:
25932 return NULL;
25933 }
25934
25935
25936 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25937 PyObject *resultobj = 0;
25938 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25939 unsigned int arg2 ;
25940 void *argp1 = 0 ;
25941 int res1 = 0 ;
25942 unsigned int val2 ;
25943 int ecode2 = 0 ;
25944 PyObject *swig_obj[2] ;
25945
25946 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
25947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25948 if (!SWIG_IsOK(res1)) {
25949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25950 }
25951 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25952 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
25953 if (!SWIG_IsOK(ecode2)) {
25954 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
25955 }
25956 arg2 = static_cast< unsigned int >(val2);
25957 if (arg1) (arg1)->m_rawFlags = arg2;
25958
25959 resultobj = SWIG_Py_Void();
25960 return resultobj;
25961 fail:
25962 return NULL;
25963 }
25964
25965
25966 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25967 PyObject *resultobj = 0;
25968 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25969 unsigned int result;
25970 void *argp1 = 0 ;
25971 int res1 = 0 ;
25972 PyObject *swig_obj[1] ;
25973
25974 if (!args) SWIG_fail;
25975 swig_obj[0] = args;
25976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25977 if (!SWIG_IsOK(res1)) {
25978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25979 }
25980 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25981 result = (unsigned int) ((arg1)->m_rawFlags);
25982 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25983 return resultobj;
25984 fail:
25985 return NULL;
25986 }
25987
25988
25989 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25990 PyObject *obj;
25991 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25992 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
25993 return SWIG_Py_Void();
25994 }
25995
25996 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25997 return SWIG_Python_InitShadowInstance(args);
25998 }
25999
26000 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26001 PyObject *resultobj = 0;
26002 wxSize const &arg1_defvalue = wxDefaultSize ;
26003 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
26004 int arg2 = (int) 0 ;
26005 wxSizeEvent *result = 0 ;
26006 wxSize temp1 ;
26007 int val2 ;
26008 int ecode2 = 0 ;
26009 PyObject * obj0 = 0 ;
26010 PyObject * obj1 = 0 ;
26011 char * kwnames[] = {
26012 (char *) "sz",(char *) "winid", NULL
26013 };
26014
26015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26016 if (obj0) {
26017 {
26018 arg1 = &temp1;
26019 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
26020 }
26021 }
26022 if (obj1) {
26023 ecode2 = SWIG_AsVal_int(obj1, &val2);
26024 if (!SWIG_IsOK(ecode2)) {
26025 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
26026 }
26027 arg2 = static_cast< int >(val2);
26028 }
26029 {
26030 PyThreadState* __tstate = wxPyBeginAllowThreads();
26031 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
26032 wxPyEndAllowThreads(__tstate);
26033 if (PyErr_Occurred()) SWIG_fail;
26034 }
26035 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
26036 return resultobj;
26037 fail:
26038 return NULL;
26039 }
26040
26041
26042 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26043 PyObject *resultobj = 0;
26044 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26045 wxSize result;
26046 void *argp1 = 0 ;
26047 int res1 = 0 ;
26048 PyObject *swig_obj[1] ;
26049
26050 if (!args) SWIG_fail;
26051 swig_obj[0] = args;
26052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26053 if (!SWIG_IsOK(res1)) {
26054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
26055 }
26056 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26057 {
26058 PyThreadState* __tstate = wxPyBeginAllowThreads();
26059 result = ((wxSizeEvent const *)arg1)->GetSize();
26060 wxPyEndAllowThreads(__tstate);
26061 if (PyErr_Occurred()) SWIG_fail;
26062 }
26063 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
26064 return resultobj;
26065 fail:
26066 return NULL;
26067 }
26068
26069
26070 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26071 PyObject *resultobj = 0;
26072 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26073 wxRect result;
26074 void *argp1 = 0 ;
26075 int res1 = 0 ;
26076 PyObject *swig_obj[1] ;
26077
26078 if (!args) SWIG_fail;
26079 swig_obj[0] = args;
26080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26081 if (!SWIG_IsOK(res1)) {
26082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
26083 }
26084 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26085 {
26086 PyThreadState* __tstate = wxPyBeginAllowThreads();
26087 result = ((wxSizeEvent const *)arg1)->GetRect();
26088 wxPyEndAllowThreads(__tstate);
26089 if (PyErr_Occurred()) SWIG_fail;
26090 }
26091 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
26092 return resultobj;
26093 fail:
26094 return NULL;
26095 }
26096
26097
26098 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26099 PyObject *resultobj = 0;
26100 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26101 wxRect arg2 ;
26102 void *argp1 = 0 ;
26103 int res1 = 0 ;
26104 void *argp2 ;
26105 int res2 = 0 ;
26106 PyObject * obj0 = 0 ;
26107 PyObject * obj1 = 0 ;
26108 char * kwnames[] = {
26109 (char *) "self",(char *) "rect", NULL
26110 };
26111
26112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
26113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26114 if (!SWIG_IsOK(res1)) {
26115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26116 }
26117 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26118 {
26119 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
26120 if (!SWIG_IsOK(res2)) {
26121 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
26122 }
26123 if (!argp2) {
26124 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
26125 } else {
26126 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
26127 arg2 = *temp;
26128 if (SWIG_IsNewObj(res2)) delete temp;
26129 }
26130 }
26131 {
26132 PyThreadState* __tstate = wxPyBeginAllowThreads();
26133 (arg1)->SetRect(arg2);
26134 wxPyEndAllowThreads(__tstate);
26135 if (PyErr_Occurred()) SWIG_fail;
26136 }
26137 resultobj = SWIG_Py_Void();
26138 return resultobj;
26139 fail:
26140 return NULL;
26141 }
26142
26143
26144 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26145 PyObject *resultobj = 0;
26146 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26147 wxSize arg2 ;
26148 void *argp1 = 0 ;
26149 int res1 = 0 ;
26150 void *argp2 ;
26151 int res2 = 0 ;
26152 PyObject * obj0 = 0 ;
26153 PyObject * obj1 = 0 ;
26154 char * kwnames[] = {
26155 (char *) "self",(char *) "size", NULL
26156 };
26157
26158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
26159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26160 if (!SWIG_IsOK(res1)) {
26161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26162 }
26163 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26164 {
26165 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
26166 if (!SWIG_IsOK(res2)) {
26167 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
26168 }
26169 if (!argp2) {
26170 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
26171 } else {
26172 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
26173 arg2 = *temp;
26174 if (SWIG_IsNewObj(res2)) delete temp;
26175 }
26176 }
26177 {
26178 PyThreadState* __tstate = wxPyBeginAllowThreads();
26179 wxSizeEvent_SetSize(arg1,arg2);
26180 wxPyEndAllowThreads(__tstate);
26181 if (PyErr_Occurred()) SWIG_fail;
26182 }
26183 resultobj = SWIG_Py_Void();
26184 return resultobj;
26185 fail:
26186 return NULL;
26187 }
26188
26189
26190 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26191 PyObject *resultobj = 0;
26192 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26193 wxSize *arg2 = (wxSize *) 0 ;
26194 void *argp1 = 0 ;
26195 int res1 = 0 ;
26196 void *argp2 = 0 ;
26197 int res2 = 0 ;
26198 PyObject *swig_obj[2] ;
26199
26200 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
26201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26202 if (!SWIG_IsOK(res1)) {
26203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26204 }
26205 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26206 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
26207 if (!SWIG_IsOK(res2)) {
26208 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
26209 }
26210 arg2 = reinterpret_cast< wxSize * >(argp2);
26211 if (arg1) (arg1)->m_size = *arg2;
26212
26213 resultobj = SWIG_Py_Void();
26214 return resultobj;
26215 fail:
26216 return NULL;
26217 }
26218
26219
26220 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26221 PyObject *resultobj = 0;
26222 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26223 wxSize *result = 0 ;
26224 void *argp1 = 0 ;
26225 int res1 = 0 ;
26226 PyObject *swig_obj[1] ;
26227
26228 if (!args) SWIG_fail;
26229 swig_obj[0] = args;
26230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26231 if (!SWIG_IsOK(res1)) {
26232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26233 }
26234 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26235 result = (wxSize *)& ((arg1)->m_size);
26236 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
26237 return resultobj;
26238 fail:
26239 return NULL;
26240 }
26241
26242
26243 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26244 PyObject *resultobj = 0;
26245 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26246 wxRect *arg2 = (wxRect *) 0 ;
26247 void *argp1 = 0 ;
26248 int res1 = 0 ;
26249 void *argp2 = 0 ;
26250 int res2 = 0 ;
26251 PyObject *swig_obj[2] ;
26252
26253 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
26254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26255 if (!SWIG_IsOK(res1)) {
26256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26257 }
26258 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26259 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
26260 if (!SWIG_IsOK(res2)) {
26261 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
26262 }
26263 arg2 = reinterpret_cast< wxRect * >(argp2);
26264 if (arg1) (arg1)->m_rect = *arg2;
26265
26266 resultobj = SWIG_Py_Void();
26267 return resultobj;
26268 fail:
26269 return NULL;
26270 }
26271
26272
26273 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26274 PyObject *resultobj = 0;
26275 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26276 wxRect *result = 0 ;
26277 void *argp1 = 0 ;
26278 int res1 = 0 ;
26279 PyObject *swig_obj[1] ;
26280
26281 if (!args) SWIG_fail;
26282 swig_obj[0] = args;
26283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26284 if (!SWIG_IsOK(res1)) {
26285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26286 }
26287 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26288 result = (wxRect *)& ((arg1)->m_rect);
26289 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
26290 return resultobj;
26291 fail:
26292 return NULL;
26293 }
26294
26295
26296 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26297 PyObject *obj;
26298 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26299 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
26300 return SWIG_Py_Void();
26301 }
26302
26303 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26304 return SWIG_Python_InitShadowInstance(args);
26305 }
26306
26307 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26308 PyObject *resultobj = 0;
26309 wxPoint const &arg1_defvalue = wxDefaultPosition ;
26310 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
26311 int arg2 = (int) 0 ;
26312 wxMoveEvent *result = 0 ;
26313 wxPoint temp1 ;
26314 int val2 ;
26315 int ecode2 = 0 ;
26316 PyObject * obj0 = 0 ;
26317 PyObject * obj1 = 0 ;
26318 char * kwnames[] = {
26319 (char *) "pos",(char *) "winid", NULL
26320 };
26321
26322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26323 if (obj0) {
26324 {
26325 arg1 = &temp1;
26326 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
26327 }
26328 }
26329 if (obj1) {
26330 ecode2 = SWIG_AsVal_int(obj1, &val2);
26331 if (!SWIG_IsOK(ecode2)) {
26332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
26333 }
26334 arg2 = static_cast< int >(val2);
26335 }
26336 {
26337 PyThreadState* __tstate = wxPyBeginAllowThreads();
26338 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
26339 wxPyEndAllowThreads(__tstate);
26340 if (PyErr_Occurred()) SWIG_fail;
26341 }
26342 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
26343 return resultobj;
26344 fail:
26345 return NULL;
26346 }
26347
26348
26349 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26350 PyObject *resultobj = 0;
26351 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26352 wxPoint result;
26353 void *argp1 = 0 ;
26354 int res1 = 0 ;
26355 PyObject *swig_obj[1] ;
26356
26357 if (!args) SWIG_fail;
26358 swig_obj[0] = args;
26359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26360 if (!SWIG_IsOK(res1)) {
26361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
26362 }
26363 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26364 {
26365 PyThreadState* __tstate = wxPyBeginAllowThreads();
26366 result = ((wxMoveEvent const *)arg1)->GetPosition();
26367 wxPyEndAllowThreads(__tstate);
26368 if (PyErr_Occurred()) SWIG_fail;
26369 }
26370 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
26371 return resultobj;
26372 fail:
26373 return NULL;
26374 }
26375
26376
26377 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26378 PyObject *resultobj = 0;
26379 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26380 wxRect result;
26381 void *argp1 = 0 ;
26382 int res1 = 0 ;
26383 PyObject *swig_obj[1] ;
26384
26385 if (!args) SWIG_fail;
26386 swig_obj[0] = args;
26387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26388 if (!SWIG_IsOK(res1)) {
26389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
26390 }
26391 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26392 {
26393 PyThreadState* __tstate = wxPyBeginAllowThreads();
26394 result = ((wxMoveEvent const *)arg1)->GetRect();
26395 wxPyEndAllowThreads(__tstate);
26396 if (PyErr_Occurred()) SWIG_fail;
26397 }
26398 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
26399 return resultobj;
26400 fail:
26401 return NULL;
26402 }
26403
26404
26405 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26406 PyObject *resultobj = 0;
26407 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26408 wxRect *arg2 = 0 ;
26409 void *argp1 = 0 ;
26410 int res1 = 0 ;
26411 wxRect temp2 ;
26412 PyObject * obj0 = 0 ;
26413 PyObject * obj1 = 0 ;
26414 char * kwnames[] = {
26415 (char *) "self",(char *) "rect", NULL
26416 };
26417
26418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
26419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26420 if (!SWIG_IsOK(res1)) {
26421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
26422 }
26423 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26424 {
26425 arg2 = &temp2;
26426 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26427 }
26428 {
26429 PyThreadState* __tstate = wxPyBeginAllowThreads();
26430 (arg1)->SetRect((wxRect const &)*arg2);
26431 wxPyEndAllowThreads(__tstate);
26432 if (PyErr_Occurred()) SWIG_fail;
26433 }
26434 resultobj = SWIG_Py_Void();
26435 return resultobj;
26436 fail:
26437 return NULL;
26438 }
26439
26440
26441 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26442 PyObject *resultobj = 0;
26443 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26444 wxPoint *arg2 = 0 ;
26445 void *argp1 = 0 ;
26446 int res1 = 0 ;
26447 wxPoint temp2 ;
26448 PyObject * obj0 = 0 ;
26449 PyObject * obj1 = 0 ;
26450 char * kwnames[] = {
26451 (char *) "self",(char *) "pos", NULL
26452 };
26453
26454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26455 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26456 if (!SWIG_IsOK(res1)) {
26457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
26458 }
26459 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26460 {
26461 arg2 = &temp2;
26462 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26463 }
26464 {
26465 PyThreadState* __tstate = wxPyBeginAllowThreads();
26466 (arg1)->SetPosition((wxPoint const &)*arg2);
26467 wxPyEndAllowThreads(__tstate);
26468 if (PyErr_Occurred()) SWIG_fail;
26469 }
26470 resultobj = SWIG_Py_Void();
26471 return resultobj;
26472 fail:
26473 return NULL;
26474 }
26475
26476
26477 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26478 PyObject *obj;
26479 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26480 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
26481 return SWIG_Py_Void();
26482 }
26483
26484 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26485 return SWIG_Python_InitShadowInstance(args);
26486 }
26487
26488 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26489 PyObject *resultobj = 0;
26490 int arg1 = (int) 0 ;
26491 wxPaintEvent *result = 0 ;
26492 int val1 ;
26493 int ecode1 = 0 ;
26494 PyObject * obj0 = 0 ;
26495 char * kwnames[] = {
26496 (char *) "Id", NULL
26497 };
26498
26499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
26500 if (obj0) {
26501 ecode1 = SWIG_AsVal_int(obj0, &val1);
26502 if (!SWIG_IsOK(ecode1)) {
26503 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
26504 }
26505 arg1 = static_cast< int >(val1);
26506 }
26507 {
26508 PyThreadState* __tstate = wxPyBeginAllowThreads();
26509 result = (wxPaintEvent *)new wxPaintEvent(arg1);
26510 wxPyEndAllowThreads(__tstate);
26511 if (PyErr_Occurred()) SWIG_fail;
26512 }
26513 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
26514 return resultobj;
26515 fail:
26516 return NULL;
26517 }
26518
26519
26520 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26521 PyObject *obj;
26522 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26523 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
26524 return SWIG_Py_Void();
26525 }
26526
26527 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26528 return SWIG_Python_InitShadowInstance(args);
26529 }
26530
26531 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26532 PyObject *resultobj = 0;
26533 int arg1 = (int) 0 ;
26534 wxNcPaintEvent *result = 0 ;
26535 int val1 ;
26536 int ecode1 = 0 ;
26537 PyObject * obj0 = 0 ;
26538 char * kwnames[] = {
26539 (char *) "winid", NULL
26540 };
26541
26542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
26543 if (obj0) {
26544 ecode1 = SWIG_AsVal_int(obj0, &val1);
26545 if (!SWIG_IsOK(ecode1)) {
26546 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
26547 }
26548 arg1 = static_cast< int >(val1);
26549 }
26550 {
26551 PyThreadState* __tstate = wxPyBeginAllowThreads();
26552 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
26553 wxPyEndAllowThreads(__tstate);
26554 if (PyErr_Occurred()) SWIG_fail;
26555 }
26556 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
26557 return resultobj;
26558 fail:
26559 return NULL;
26560 }
26561
26562
26563 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26564 PyObject *obj;
26565 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26566 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
26567 return SWIG_Py_Void();
26568 }
26569
26570 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26571 return SWIG_Python_InitShadowInstance(args);
26572 }
26573
26574 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26575 PyObject *resultobj = 0;
26576 int arg1 = (int) 0 ;
26577 wxDC *arg2 = (wxDC *) NULL ;
26578 wxEraseEvent *result = 0 ;
26579 int val1 ;
26580 int ecode1 = 0 ;
26581 void *argp2 = 0 ;
26582 int res2 = 0 ;
26583 PyObject * obj0 = 0 ;
26584 PyObject * obj1 = 0 ;
26585 char * kwnames[] = {
26586 (char *) "Id",(char *) "dc", NULL
26587 };
26588
26589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26590 if (obj0) {
26591 ecode1 = SWIG_AsVal_int(obj0, &val1);
26592 if (!SWIG_IsOK(ecode1)) {
26593 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
26594 }
26595 arg1 = static_cast< int >(val1);
26596 }
26597 if (obj1) {
26598 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
26599 if (!SWIG_IsOK(res2)) {
26600 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
26601 }
26602 arg2 = reinterpret_cast< wxDC * >(argp2);
26603 }
26604 {
26605 PyThreadState* __tstate = wxPyBeginAllowThreads();
26606 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
26607 wxPyEndAllowThreads(__tstate);
26608 if (PyErr_Occurred()) SWIG_fail;
26609 }
26610 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
26611 return resultobj;
26612 fail:
26613 return NULL;
26614 }
26615
26616
26617 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26618 PyObject *resultobj = 0;
26619 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
26620 wxDC *result = 0 ;
26621 void *argp1 = 0 ;
26622 int res1 = 0 ;
26623 PyObject *swig_obj[1] ;
26624
26625 if (!args) SWIG_fail;
26626 swig_obj[0] = args;
26627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
26628 if (!SWIG_IsOK(res1)) {
26629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
26630 }
26631 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
26632 {
26633 PyThreadState* __tstate = wxPyBeginAllowThreads();
26634 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
26635 wxPyEndAllowThreads(__tstate);
26636 if (PyErr_Occurred()) SWIG_fail;
26637 }
26638 {
26639 resultobj = wxPyMake_wxObject(result, (bool)0);
26640 }
26641 return resultobj;
26642 fail:
26643 return NULL;
26644 }
26645
26646
26647 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26648 PyObject *obj;
26649 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26650 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
26651 return SWIG_Py_Void();
26652 }
26653
26654 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26655 return SWIG_Python_InitShadowInstance(args);
26656 }
26657
26658 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26659 PyObject *resultobj = 0;
26660 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26661 int arg2 = (int) 0 ;
26662 wxFocusEvent *result = 0 ;
26663 int val1 ;
26664 int ecode1 = 0 ;
26665 int val2 ;
26666 int ecode2 = 0 ;
26667 PyObject * obj0 = 0 ;
26668 PyObject * obj1 = 0 ;
26669 char * kwnames[] = {
26670 (char *) "type",(char *) "winid", NULL
26671 };
26672
26673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26674 if (obj0) {
26675 ecode1 = SWIG_AsVal_int(obj0, &val1);
26676 if (!SWIG_IsOK(ecode1)) {
26677 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26678 }
26679 arg1 = static_cast< wxEventType >(val1);
26680 }
26681 if (obj1) {
26682 ecode2 = SWIG_AsVal_int(obj1, &val2);
26683 if (!SWIG_IsOK(ecode2)) {
26684 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
26685 }
26686 arg2 = static_cast< int >(val2);
26687 }
26688 {
26689 PyThreadState* __tstate = wxPyBeginAllowThreads();
26690 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
26691 wxPyEndAllowThreads(__tstate);
26692 if (PyErr_Occurred()) SWIG_fail;
26693 }
26694 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
26695 return resultobj;
26696 fail:
26697 return NULL;
26698 }
26699
26700
26701 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26702 PyObject *resultobj = 0;
26703 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
26704 wxWindow *result = 0 ;
26705 void *argp1 = 0 ;
26706 int res1 = 0 ;
26707 PyObject *swig_obj[1] ;
26708
26709 if (!args) SWIG_fail;
26710 swig_obj[0] = args;
26711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
26712 if (!SWIG_IsOK(res1)) {
26713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
26714 }
26715 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
26716 {
26717 PyThreadState* __tstate = wxPyBeginAllowThreads();
26718 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
26719 wxPyEndAllowThreads(__tstate);
26720 if (PyErr_Occurred()) SWIG_fail;
26721 }
26722 {
26723 resultobj = wxPyMake_wxObject(result, (bool)0);
26724 }
26725 return resultobj;
26726 fail:
26727 return NULL;
26728 }
26729
26730
26731 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26732 PyObject *resultobj = 0;
26733 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
26734 wxWindow *arg2 = (wxWindow *) 0 ;
26735 void *argp1 = 0 ;
26736 int res1 = 0 ;
26737 void *argp2 = 0 ;
26738 int res2 = 0 ;
26739 PyObject * obj0 = 0 ;
26740 PyObject * obj1 = 0 ;
26741 char * kwnames[] = {
26742 (char *) "self",(char *) "win", NULL
26743 };
26744
26745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
26746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
26747 if (!SWIG_IsOK(res1)) {
26748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
26749 }
26750 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
26751 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26752 if (!SWIG_IsOK(res2)) {
26753 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
26754 }
26755 arg2 = reinterpret_cast< wxWindow * >(argp2);
26756 {
26757 PyThreadState* __tstate = wxPyBeginAllowThreads();
26758 (arg1)->SetWindow(arg2);
26759 wxPyEndAllowThreads(__tstate);
26760 if (PyErr_Occurred()) SWIG_fail;
26761 }
26762 resultobj = SWIG_Py_Void();
26763 return resultobj;
26764 fail:
26765 return NULL;
26766 }
26767
26768
26769 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26770 PyObject *obj;
26771 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26772 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
26773 return SWIG_Py_Void();
26774 }
26775
26776 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26777 return SWIG_Python_InitShadowInstance(args);
26778 }
26779
26780 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26781 PyObject *resultobj = 0;
26782 wxWindow *arg1 = (wxWindow *) NULL ;
26783 wxChildFocusEvent *result = 0 ;
26784 void *argp1 = 0 ;
26785 int res1 = 0 ;
26786 PyObject * obj0 = 0 ;
26787 char * kwnames[] = {
26788 (char *) "win", NULL
26789 };
26790
26791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
26792 if (obj0) {
26793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26794 if (!SWIG_IsOK(res1)) {
26795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26796 }
26797 arg1 = reinterpret_cast< wxWindow * >(argp1);
26798 }
26799 {
26800 PyThreadState* __tstate = wxPyBeginAllowThreads();
26801 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
26802 wxPyEndAllowThreads(__tstate);
26803 if (PyErr_Occurred()) SWIG_fail;
26804 }
26805 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
26806 return resultobj;
26807 fail:
26808 return NULL;
26809 }
26810
26811
26812 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26813 PyObject *resultobj = 0;
26814 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
26815 wxWindow *result = 0 ;
26816 void *argp1 = 0 ;
26817 int res1 = 0 ;
26818 PyObject *swig_obj[1] ;
26819
26820 if (!args) SWIG_fail;
26821 swig_obj[0] = args;
26822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
26823 if (!SWIG_IsOK(res1)) {
26824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
26825 }
26826 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
26827 {
26828 PyThreadState* __tstate = wxPyBeginAllowThreads();
26829 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
26830 wxPyEndAllowThreads(__tstate);
26831 if (PyErr_Occurred()) SWIG_fail;
26832 }
26833 {
26834 resultobj = wxPyMake_wxObject(result, (bool)0);
26835 }
26836 return resultobj;
26837 fail:
26838 return NULL;
26839 }
26840
26841
26842 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26843 PyObject *obj;
26844 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26845 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
26846 return SWIG_Py_Void();
26847 }
26848
26849 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26850 return SWIG_Python_InitShadowInstance(args);
26851 }
26852
26853 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26854 PyObject *resultobj = 0;
26855 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26856 bool arg2 = (bool) true ;
26857 int arg3 = (int) 0 ;
26858 wxActivateEvent *result = 0 ;
26859 int val1 ;
26860 int ecode1 = 0 ;
26861 bool val2 ;
26862 int ecode2 = 0 ;
26863 int val3 ;
26864 int ecode3 = 0 ;
26865 PyObject * obj0 = 0 ;
26866 PyObject * obj1 = 0 ;
26867 PyObject * obj2 = 0 ;
26868 char * kwnames[] = {
26869 (char *) "type",(char *) "active",(char *) "Id", NULL
26870 };
26871
26872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26873 if (obj0) {
26874 ecode1 = SWIG_AsVal_int(obj0, &val1);
26875 if (!SWIG_IsOK(ecode1)) {
26876 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26877 }
26878 arg1 = static_cast< wxEventType >(val1);
26879 }
26880 if (obj1) {
26881 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26882 if (!SWIG_IsOK(ecode2)) {
26883 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
26884 }
26885 arg2 = static_cast< bool >(val2);
26886 }
26887 if (obj2) {
26888 ecode3 = SWIG_AsVal_int(obj2, &val3);
26889 if (!SWIG_IsOK(ecode3)) {
26890 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
26891 }
26892 arg3 = static_cast< int >(val3);
26893 }
26894 {
26895 PyThreadState* __tstate = wxPyBeginAllowThreads();
26896 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
26897 wxPyEndAllowThreads(__tstate);
26898 if (PyErr_Occurred()) SWIG_fail;
26899 }
26900 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
26901 return resultobj;
26902 fail:
26903 return NULL;
26904 }
26905
26906
26907 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26908 PyObject *resultobj = 0;
26909 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
26910 bool result;
26911 void *argp1 = 0 ;
26912 int res1 = 0 ;
26913 PyObject *swig_obj[1] ;
26914
26915 if (!args) SWIG_fail;
26916 swig_obj[0] = args;
26917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
26918 if (!SWIG_IsOK(res1)) {
26919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
26920 }
26921 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
26922 {
26923 PyThreadState* __tstate = wxPyBeginAllowThreads();
26924 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
26925 wxPyEndAllowThreads(__tstate);
26926 if (PyErr_Occurred()) SWIG_fail;
26927 }
26928 {
26929 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26930 }
26931 return resultobj;
26932 fail:
26933 return NULL;
26934 }
26935
26936
26937 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26938 PyObject *obj;
26939 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26940 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
26941 return SWIG_Py_Void();
26942 }
26943
26944 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26945 return SWIG_Python_InitShadowInstance(args);
26946 }
26947
26948 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26949 PyObject *resultobj = 0;
26950 int arg1 = (int) 0 ;
26951 wxInitDialogEvent *result = 0 ;
26952 int val1 ;
26953 int ecode1 = 0 ;
26954 PyObject * obj0 = 0 ;
26955 char * kwnames[] = {
26956 (char *) "Id", NULL
26957 };
26958
26959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
26960 if (obj0) {
26961 ecode1 = SWIG_AsVal_int(obj0, &val1);
26962 if (!SWIG_IsOK(ecode1)) {
26963 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
26964 }
26965 arg1 = static_cast< int >(val1);
26966 }
26967 {
26968 PyThreadState* __tstate = wxPyBeginAllowThreads();
26969 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
26970 wxPyEndAllowThreads(__tstate);
26971 if (PyErr_Occurred()) SWIG_fail;
26972 }
26973 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
26974 return resultobj;
26975 fail:
26976 return NULL;
26977 }
26978
26979
26980 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26981 PyObject *obj;
26982 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26983 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
26984 return SWIG_Py_Void();
26985 }
26986
26987 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26988 return SWIG_Python_InitShadowInstance(args);
26989 }
26990
26991 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26992 PyObject *resultobj = 0;
26993 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26994 int arg2 = (int) 0 ;
26995 wxMenu *arg3 = (wxMenu *) NULL ;
26996 wxMenuEvent *result = 0 ;
26997 int val1 ;
26998 int ecode1 = 0 ;
26999 int val2 ;
27000 int ecode2 = 0 ;
27001 void *argp3 = 0 ;
27002 int res3 = 0 ;
27003 PyObject * obj0 = 0 ;
27004 PyObject * obj1 = 0 ;
27005 PyObject * obj2 = 0 ;
27006 char * kwnames[] = {
27007 (char *) "type",(char *) "winid",(char *) "menu", NULL
27008 };
27009
27010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27011 if (obj0) {
27012 ecode1 = SWIG_AsVal_int(obj0, &val1);
27013 if (!SWIG_IsOK(ecode1)) {
27014 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27015 }
27016 arg1 = static_cast< wxEventType >(val1);
27017 }
27018 if (obj1) {
27019 ecode2 = SWIG_AsVal_int(obj1, &val2);
27020 if (!SWIG_IsOK(ecode2)) {
27021 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
27022 }
27023 arg2 = static_cast< int >(val2);
27024 }
27025 if (obj2) {
27026 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
27027 if (!SWIG_IsOK(res3)) {
27028 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
27029 }
27030 arg3 = reinterpret_cast< wxMenu * >(argp3);
27031 }
27032 {
27033 PyThreadState* __tstate = wxPyBeginAllowThreads();
27034 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
27035 wxPyEndAllowThreads(__tstate);
27036 if (PyErr_Occurred()) SWIG_fail;
27037 }
27038 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
27039 return resultobj;
27040 fail:
27041 return NULL;
27042 }
27043
27044
27045 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27046 PyObject *resultobj = 0;
27047 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27048 int result;
27049 void *argp1 = 0 ;
27050 int res1 = 0 ;
27051 PyObject *swig_obj[1] ;
27052
27053 if (!args) SWIG_fail;
27054 swig_obj[0] = args;
27055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27056 if (!SWIG_IsOK(res1)) {
27057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27058 }
27059 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27060 {
27061 PyThreadState* __tstate = wxPyBeginAllowThreads();
27062 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
27063 wxPyEndAllowThreads(__tstate);
27064 if (PyErr_Occurred()) SWIG_fail;
27065 }
27066 resultobj = SWIG_From_int(static_cast< int >(result));
27067 return resultobj;
27068 fail:
27069 return NULL;
27070 }
27071
27072
27073 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27074 PyObject *resultobj = 0;
27075 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27076 bool result;
27077 void *argp1 = 0 ;
27078 int res1 = 0 ;
27079 PyObject *swig_obj[1] ;
27080
27081 if (!args) SWIG_fail;
27082 swig_obj[0] = args;
27083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27084 if (!SWIG_IsOK(res1)) {
27085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27086 }
27087 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27088 {
27089 PyThreadState* __tstate = wxPyBeginAllowThreads();
27090 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
27091 wxPyEndAllowThreads(__tstate);
27092 if (PyErr_Occurred()) SWIG_fail;
27093 }
27094 {
27095 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27096 }
27097 return resultobj;
27098 fail:
27099 return NULL;
27100 }
27101
27102
27103 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27104 PyObject *resultobj = 0;
27105 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27106 wxMenu *result = 0 ;
27107 void *argp1 = 0 ;
27108 int res1 = 0 ;
27109 PyObject *swig_obj[1] ;
27110
27111 if (!args) SWIG_fail;
27112 swig_obj[0] = args;
27113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27114 if (!SWIG_IsOK(res1)) {
27115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27116 }
27117 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27118 {
27119 PyThreadState* __tstate = wxPyBeginAllowThreads();
27120 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
27121 wxPyEndAllowThreads(__tstate);
27122 if (PyErr_Occurred()) SWIG_fail;
27123 }
27124 {
27125 resultobj = wxPyMake_wxObject(result, (bool)0);
27126 }
27127 return resultobj;
27128 fail:
27129 return NULL;
27130 }
27131
27132
27133 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27134 PyObject *obj;
27135 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27136 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
27137 return SWIG_Py_Void();
27138 }
27139
27140 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27141 return SWIG_Python_InitShadowInstance(args);
27142 }
27143
27144 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27145 PyObject *resultobj = 0;
27146 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27147 int arg2 = (int) 0 ;
27148 wxCloseEvent *result = 0 ;
27149 int val1 ;
27150 int ecode1 = 0 ;
27151 int val2 ;
27152 int ecode2 = 0 ;
27153 PyObject * obj0 = 0 ;
27154 PyObject * obj1 = 0 ;
27155 char * kwnames[] = {
27156 (char *) "type",(char *) "winid", NULL
27157 };
27158
27159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27160 if (obj0) {
27161 ecode1 = SWIG_AsVal_int(obj0, &val1);
27162 if (!SWIG_IsOK(ecode1)) {
27163 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27164 }
27165 arg1 = static_cast< wxEventType >(val1);
27166 }
27167 if (obj1) {
27168 ecode2 = SWIG_AsVal_int(obj1, &val2);
27169 if (!SWIG_IsOK(ecode2)) {
27170 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
27171 }
27172 arg2 = static_cast< int >(val2);
27173 }
27174 {
27175 PyThreadState* __tstate = wxPyBeginAllowThreads();
27176 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
27177 wxPyEndAllowThreads(__tstate);
27178 if (PyErr_Occurred()) SWIG_fail;
27179 }
27180 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
27181 return resultobj;
27182 fail:
27183 return NULL;
27184 }
27185
27186
27187 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27188 PyObject *resultobj = 0;
27189 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27190 bool arg2 ;
27191 void *argp1 = 0 ;
27192 int res1 = 0 ;
27193 bool val2 ;
27194 int ecode2 = 0 ;
27195 PyObject * obj0 = 0 ;
27196 PyObject * obj1 = 0 ;
27197 char * kwnames[] = {
27198 (char *) "self",(char *) "logOff", NULL
27199 };
27200
27201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
27202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27203 if (!SWIG_IsOK(res1)) {
27204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27205 }
27206 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27207 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27208 if (!SWIG_IsOK(ecode2)) {
27209 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
27210 }
27211 arg2 = static_cast< bool >(val2);
27212 {
27213 PyThreadState* __tstate = wxPyBeginAllowThreads();
27214 (arg1)->SetLoggingOff(arg2);
27215 wxPyEndAllowThreads(__tstate);
27216 if (PyErr_Occurred()) SWIG_fail;
27217 }
27218 resultobj = SWIG_Py_Void();
27219 return resultobj;
27220 fail:
27221 return NULL;
27222 }
27223
27224
27225 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27226 PyObject *resultobj = 0;
27227 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27228 bool result;
27229 void *argp1 = 0 ;
27230 int res1 = 0 ;
27231 PyObject *swig_obj[1] ;
27232
27233 if (!args) SWIG_fail;
27234 swig_obj[0] = args;
27235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27236 if (!SWIG_IsOK(res1)) {
27237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27238 }
27239 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27240 {
27241 PyThreadState* __tstate = wxPyBeginAllowThreads();
27242 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
27243 wxPyEndAllowThreads(__tstate);
27244 if (PyErr_Occurred()) SWIG_fail;
27245 }
27246 {
27247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27248 }
27249 return resultobj;
27250 fail:
27251 return NULL;
27252 }
27253
27254
27255 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27256 PyObject *resultobj = 0;
27257 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27258 bool arg2 = (bool) true ;
27259 void *argp1 = 0 ;
27260 int res1 = 0 ;
27261 bool val2 ;
27262 int ecode2 = 0 ;
27263 PyObject * obj0 = 0 ;
27264 PyObject * obj1 = 0 ;
27265 char * kwnames[] = {
27266 (char *) "self",(char *) "veto", NULL
27267 };
27268
27269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
27270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27271 if (!SWIG_IsOK(res1)) {
27272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27273 }
27274 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27275 if (obj1) {
27276 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27277 if (!SWIG_IsOK(ecode2)) {
27278 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
27279 }
27280 arg2 = static_cast< bool >(val2);
27281 }
27282 {
27283 PyThreadState* __tstate = wxPyBeginAllowThreads();
27284 (arg1)->Veto(arg2);
27285 wxPyEndAllowThreads(__tstate);
27286 if (PyErr_Occurred()) SWIG_fail;
27287 }
27288 resultobj = SWIG_Py_Void();
27289 return resultobj;
27290 fail:
27291 return NULL;
27292 }
27293
27294
27295 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27296 PyObject *resultobj = 0;
27297 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27298 bool result;
27299 void *argp1 = 0 ;
27300 int res1 = 0 ;
27301 PyObject *swig_obj[1] ;
27302
27303 if (!args) SWIG_fail;
27304 swig_obj[0] = args;
27305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27306 if (!SWIG_IsOK(res1)) {
27307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27308 }
27309 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27310 {
27311 PyThreadState* __tstate = wxPyBeginAllowThreads();
27312 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
27313 wxPyEndAllowThreads(__tstate);
27314 if (PyErr_Occurred()) SWIG_fail;
27315 }
27316 {
27317 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27318 }
27319 return resultobj;
27320 fail:
27321 return NULL;
27322 }
27323
27324
27325 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27326 PyObject *resultobj = 0;
27327 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27328 bool arg2 ;
27329 void *argp1 = 0 ;
27330 int res1 = 0 ;
27331 bool val2 ;
27332 int ecode2 = 0 ;
27333 PyObject * obj0 = 0 ;
27334 PyObject * obj1 = 0 ;
27335 char * kwnames[] = {
27336 (char *) "self",(char *) "canVeto", NULL
27337 };
27338
27339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
27340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27341 if (!SWIG_IsOK(res1)) {
27342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27343 }
27344 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27345 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27346 if (!SWIG_IsOK(ecode2)) {
27347 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
27348 }
27349 arg2 = static_cast< bool >(val2);
27350 {
27351 PyThreadState* __tstate = wxPyBeginAllowThreads();
27352 (arg1)->SetCanVeto(arg2);
27353 wxPyEndAllowThreads(__tstate);
27354 if (PyErr_Occurred()) SWIG_fail;
27355 }
27356 resultobj = SWIG_Py_Void();
27357 return resultobj;
27358 fail:
27359 return NULL;
27360 }
27361
27362
27363 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27364 PyObject *resultobj = 0;
27365 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27366 bool result;
27367 void *argp1 = 0 ;
27368 int res1 = 0 ;
27369 PyObject *swig_obj[1] ;
27370
27371 if (!args) SWIG_fail;
27372 swig_obj[0] = args;
27373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27374 if (!SWIG_IsOK(res1)) {
27375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27376 }
27377 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27378 {
27379 PyThreadState* __tstate = wxPyBeginAllowThreads();
27380 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
27381 wxPyEndAllowThreads(__tstate);
27382 if (PyErr_Occurred()) SWIG_fail;
27383 }
27384 {
27385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27386 }
27387 return resultobj;
27388 fail:
27389 return NULL;
27390 }
27391
27392
27393 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27394 PyObject *obj;
27395 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27396 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
27397 return SWIG_Py_Void();
27398 }
27399
27400 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27401 return SWIG_Python_InitShadowInstance(args);
27402 }
27403
27404 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27405 PyObject *resultobj = 0;
27406 int arg1 = (int) 0 ;
27407 bool arg2 = (bool) false ;
27408 wxShowEvent *result = 0 ;
27409 int val1 ;
27410 int ecode1 = 0 ;
27411 bool val2 ;
27412 int ecode2 = 0 ;
27413 PyObject * obj0 = 0 ;
27414 PyObject * obj1 = 0 ;
27415 char * kwnames[] = {
27416 (char *) "winid",(char *) "show", NULL
27417 };
27418
27419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27420 if (obj0) {
27421 ecode1 = SWIG_AsVal_int(obj0, &val1);
27422 if (!SWIG_IsOK(ecode1)) {
27423 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
27424 }
27425 arg1 = static_cast< int >(val1);
27426 }
27427 if (obj1) {
27428 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27429 if (!SWIG_IsOK(ecode2)) {
27430 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
27431 }
27432 arg2 = static_cast< bool >(val2);
27433 }
27434 {
27435 PyThreadState* __tstate = wxPyBeginAllowThreads();
27436 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
27437 wxPyEndAllowThreads(__tstate);
27438 if (PyErr_Occurred()) SWIG_fail;
27439 }
27440 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
27441 return resultobj;
27442 fail:
27443 return NULL;
27444 }
27445
27446
27447 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27448 PyObject *resultobj = 0;
27449 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
27450 bool arg2 ;
27451 void *argp1 = 0 ;
27452 int res1 = 0 ;
27453 bool val2 ;
27454 int ecode2 = 0 ;
27455 PyObject * obj0 = 0 ;
27456 PyObject * obj1 = 0 ;
27457 char * kwnames[] = {
27458 (char *) "self",(char *) "show", NULL
27459 };
27460
27461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
27462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
27463 if (!SWIG_IsOK(res1)) {
27464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
27465 }
27466 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
27467 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27468 if (!SWIG_IsOK(ecode2)) {
27469 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
27470 }
27471 arg2 = static_cast< bool >(val2);
27472 {
27473 PyThreadState* __tstate = wxPyBeginAllowThreads();
27474 (arg1)->SetShow(arg2);
27475 wxPyEndAllowThreads(__tstate);
27476 if (PyErr_Occurred()) SWIG_fail;
27477 }
27478 resultobj = SWIG_Py_Void();
27479 return resultobj;
27480 fail:
27481 return NULL;
27482 }
27483
27484
27485 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27486 PyObject *resultobj = 0;
27487 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
27488 bool result;
27489 void *argp1 = 0 ;
27490 int res1 = 0 ;
27491 PyObject *swig_obj[1] ;
27492
27493 if (!args) SWIG_fail;
27494 swig_obj[0] = args;
27495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
27496 if (!SWIG_IsOK(res1)) {
27497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
27498 }
27499 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
27500 {
27501 PyThreadState* __tstate = wxPyBeginAllowThreads();
27502 result = (bool)((wxShowEvent const *)arg1)->GetShow();
27503 wxPyEndAllowThreads(__tstate);
27504 if (PyErr_Occurred()) SWIG_fail;
27505 }
27506 {
27507 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27508 }
27509 return resultobj;
27510 fail:
27511 return NULL;
27512 }
27513
27514
27515 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27516 PyObject *obj;
27517 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27518 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
27519 return SWIG_Py_Void();
27520 }
27521
27522 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27523 return SWIG_Python_InitShadowInstance(args);
27524 }
27525
27526 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27527 PyObject *resultobj = 0;
27528 int arg1 = (int) 0 ;
27529 bool arg2 = (bool) true ;
27530 wxIconizeEvent *result = 0 ;
27531 int val1 ;
27532 int ecode1 = 0 ;
27533 bool val2 ;
27534 int ecode2 = 0 ;
27535 PyObject * obj0 = 0 ;
27536 PyObject * obj1 = 0 ;
27537 char * kwnames[] = {
27538 (char *) "id",(char *) "iconized", NULL
27539 };
27540
27541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27542 if (obj0) {
27543 ecode1 = SWIG_AsVal_int(obj0, &val1);
27544 if (!SWIG_IsOK(ecode1)) {
27545 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
27546 }
27547 arg1 = static_cast< int >(val1);
27548 }
27549 if (obj1) {
27550 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27551 if (!SWIG_IsOK(ecode2)) {
27552 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
27553 }
27554 arg2 = static_cast< bool >(val2);
27555 }
27556 {
27557 PyThreadState* __tstate = wxPyBeginAllowThreads();
27558 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
27559 wxPyEndAllowThreads(__tstate);
27560 if (PyErr_Occurred()) SWIG_fail;
27561 }
27562 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
27563 return resultobj;
27564 fail:
27565 return NULL;
27566 }
27567
27568
27569 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27570 PyObject *resultobj = 0;
27571 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
27572 bool result;
27573 void *argp1 = 0 ;
27574 int res1 = 0 ;
27575 PyObject *swig_obj[1] ;
27576
27577 if (!args) SWIG_fail;
27578 swig_obj[0] = args;
27579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
27580 if (!SWIG_IsOK(res1)) {
27581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
27582 }
27583 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
27584 {
27585 PyThreadState* __tstate = wxPyBeginAllowThreads();
27586 result = (bool)(arg1)->Iconized();
27587 wxPyEndAllowThreads(__tstate);
27588 if (PyErr_Occurred()) SWIG_fail;
27589 }
27590 {
27591 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27592 }
27593 return resultobj;
27594 fail:
27595 return NULL;
27596 }
27597
27598
27599 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27600 PyObject *obj;
27601 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27602 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
27603 return SWIG_Py_Void();
27604 }
27605
27606 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27607 return SWIG_Python_InitShadowInstance(args);
27608 }
27609
27610 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27611 PyObject *resultobj = 0;
27612 int arg1 = (int) 0 ;
27613 wxMaximizeEvent *result = 0 ;
27614 int val1 ;
27615 int ecode1 = 0 ;
27616 PyObject * obj0 = 0 ;
27617 char * kwnames[] = {
27618 (char *) "id", NULL
27619 };
27620
27621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
27622 if (obj0) {
27623 ecode1 = SWIG_AsVal_int(obj0, &val1);
27624 if (!SWIG_IsOK(ecode1)) {
27625 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
27626 }
27627 arg1 = static_cast< int >(val1);
27628 }
27629 {
27630 PyThreadState* __tstate = wxPyBeginAllowThreads();
27631 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
27632 wxPyEndAllowThreads(__tstate);
27633 if (PyErr_Occurred()) SWIG_fail;
27634 }
27635 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
27636 return resultobj;
27637 fail:
27638 return NULL;
27639 }
27640
27641
27642 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27643 PyObject *obj;
27644 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27645 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
27646 return SWIG_Py_Void();
27647 }
27648
27649 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27650 return SWIG_Python_InitShadowInstance(args);
27651 }
27652
27653 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27654 PyObject *resultobj = 0;
27655 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27656 wxPoint result;
27657 void *argp1 = 0 ;
27658 int res1 = 0 ;
27659 PyObject *swig_obj[1] ;
27660
27661 if (!args) SWIG_fail;
27662 swig_obj[0] = args;
27663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27664 if (!SWIG_IsOK(res1)) {
27665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27666 }
27667 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27668 {
27669 PyThreadState* __tstate = wxPyBeginAllowThreads();
27670 result = (arg1)->GetPosition();
27671 wxPyEndAllowThreads(__tstate);
27672 if (PyErr_Occurred()) SWIG_fail;
27673 }
27674 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
27675 return resultobj;
27676 fail:
27677 return NULL;
27678 }
27679
27680
27681 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27682 PyObject *resultobj = 0;
27683 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27684 int result;
27685 void *argp1 = 0 ;
27686 int res1 = 0 ;
27687 PyObject *swig_obj[1] ;
27688
27689 if (!args) SWIG_fail;
27690 swig_obj[0] = args;
27691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27692 if (!SWIG_IsOK(res1)) {
27693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27694 }
27695 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27696 {
27697 PyThreadState* __tstate = wxPyBeginAllowThreads();
27698 result = (int)(arg1)->GetNumberOfFiles();
27699 wxPyEndAllowThreads(__tstate);
27700 if (PyErr_Occurred()) SWIG_fail;
27701 }
27702 resultobj = SWIG_From_int(static_cast< int >(result));
27703 return resultobj;
27704 fail:
27705 return NULL;
27706 }
27707
27708
27709 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27710 PyObject *resultobj = 0;
27711 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27712 PyObject *result = 0 ;
27713 void *argp1 = 0 ;
27714 int res1 = 0 ;
27715 PyObject *swig_obj[1] ;
27716
27717 if (!args) SWIG_fail;
27718 swig_obj[0] = args;
27719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27720 if (!SWIG_IsOK(res1)) {
27721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27722 }
27723 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27724 {
27725 PyThreadState* __tstate = wxPyBeginAllowThreads();
27726 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
27727 wxPyEndAllowThreads(__tstate);
27728 if (PyErr_Occurred()) SWIG_fail;
27729 }
27730 resultobj = result;
27731 return resultobj;
27732 fail:
27733 return NULL;
27734 }
27735
27736
27737 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27738 PyObject *obj;
27739 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27740 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
27741 return SWIG_Py_Void();
27742 }
27743
27744 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27745 PyObject *resultobj = 0;
27746 int arg1 = (int) 0 ;
27747 wxUpdateUIEvent *result = 0 ;
27748 int val1 ;
27749 int ecode1 = 0 ;
27750 PyObject * obj0 = 0 ;
27751 char * kwnames[] = {
27752 (char *) "commandId", NULL
27753 };
27754
27755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
27756 if (obj0) {
27757 ecode1 = SWIG_AsVal_int(obj0, &val1);
27758 if (!SWIG_IsOK(ecode1)) {
27759 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
27760 }
27761 arg1 = static_cast< int >(val1);
27762 }
27763 {
27764 PyThreadState* __tstate = wxPyBeginAllowThreads();
27765 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
27766 wxPyEndAllowThreads(__tstate);
27767 if (PyErr_Occurred()) SWIG_fail;
27768 }
27769 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
27770 return resultobj;
27771 fail:
27772 return NULL;
27773 }
27774
27775
27776 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27777 PyObject *resultobj = 0;
27778 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27779 bool result;
27780 void *argp1 = 0 ;
27781 int res1 = 0 ;
27782 PyObject *swig_obj[1] ;
27783
27784 if (!args) SWIG_fail;
27785 swig_obj[0] = args;
27786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27787 if (!SWIG_IsOK(res1)) {
27788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27789 }
27790 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27791 {
27792 PyThreadState* __tstate = wxPyBeginAllowThreads();
27793 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
27794 wxPyEndAllowThreads(__tstate);
27795 if (PyErr_Occurred()) SWIG_fail;
27796 }
27797 {
27798 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27799 }
27800 return resultobj;
27801 fail:
27802 return NULL;
27803 }
27804
27805
27806 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27807 PyObject *resultobj = 0;
27808 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27809 bool result;
27810 void *argp1 = 0 ;
27811 int res1 = 0 ;
27812 PyObject *swig_obj[1] ;
27813
27814 if (!args) SWIG_fail;
27815 swig_obj[0] = args;
27816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27817 if (!SWIG_IsOK(res1)) {
27818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27819 }
27820 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27821 {
27822 PyThreadState* __tstate = wxPyBeginAllowThreads();
27823 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
27824 wxPyEndAllowThreads(__tstate);
27825 if (PyErr_Occurred()) SWIG_fail;
27826 }
27827 {
27828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27829 }
27830 return resultobj;
27831 fail:
27832 return NULL;
27833 }
27834
27835
27836 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27837 PyObject *resultobj = 0;
27838 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27839 bool result;
27840 void *argp1 = 0 ;
27841 int res1 = 0 ;
27842 PyObject *swig_obj[1] ;
27843
27844 if (!args) SWIG_fail;
27845 swig_obj[0] = args;
27846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27847 if (!SWIG_IsOK(res1)) {
27848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27849 }
27850 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27851 {
27852 PyThreadState* __tstate = wxPyBeginAllowThreads();
27853 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
27854 wxPyEndAllowThreads(__tstate);
27855 if (PyErr_Occurred()) SWIG_fail;
27856 }
27857 {
27858 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27859 }
27860 return resultobj;
27861 fail:
27862 return NULL;
27863 }
27864
27865
27866 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27867 PyObject *resultobj = 0;
27868 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27869 wxString result;
27870 void *argp1 = 0 ;
27871 int res1 = 0 ;
27872 PyObject *swig_obj[1] ;
27873
27874 if (!args) SWIG_fail;
27875 swig_obj[0] = args;
27876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27877 if (!SWIG_IsOK(res1)) {
27878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27879 }
27880 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27881 {
27882 PyThreadState* __tstate = wxPyBeginAllowThreads();
27883 result = ((wxUpdateUIEvent const *)arg1)->GetText();
27884 wxPyEndAllowThreads(__tstate);
27885 if (PyErr_Occurred()) SWIG_fail;
27886 }
27887 {
27888 #if wxUSE_UNICODE
27889 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27890 #else
27891 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27892 #endif
27893 }
27894 return resultobj;
27895 fail:
27896 return NULL;
27897 }
27898
27899
27900 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27901 PyObject *resultobj = 0;
27902 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27903 bool result;
27904 void *argp1 = 0 ;
27905 int res1 = 0 ;
27906 PyObject *swig_obj[1] ;
27907
27908 if (!args) SWIG_fail;
27909 swig_obj[0] = args;
27910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27911 if (!SWIG_IsOK(res1)) {
27912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27913 }
27914 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27915 {
27916 PyThreadState* __tstate = wxPyBeginAllowThreads();
27917 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
27918 wxPyEndAllowThreads(__tstate);
27919 if (PyErr_Occurred()) SWIG_fail;
27920 }
27921 {
27922 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27923 }
27924 return resultobj;
27925 fail:
27926 return NULL;
27927 }
27928
27929
27930 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27931 PyObject *resultobj = 0;
27932 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27933 bool result;
27934 void *argp1 = 0 ;
27935 int res1 = 0 ;
27936 PyObject *swig_obj[1] ;
27937
27938 if (!args) SWIG_fail;
27939 swig_obj[0] = args;
27940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27941 if (!SWIG_IsOK(res1)) {
27942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27943 }
27944 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27945 {
27946 PyThreadState* __tstate = wxPyBeginAllowThreads();
27947 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
27948 wxPyEndAllowThreads(__tstate);
27949 if (PyErr_Occurred()) SWIG_fail;
27950 }
27951 {
27952 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27953 }
27954 return resultobj;
27955 fail:
27956 return NULL;
27957 }
27958
27959
27960 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27961 PyObject *resultobj = 0;
27962 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27963 bool result;
27964 void *argp1 = 0 ;
27965 int res1 = 0 ;
27966 PyObject *swig_obj[1] ;
27967
27968 if (!args) SWIG_fail;
27969 swig_obj[0] = args;
27970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27971 if (!SWIG_IsOK(res1)) {
27972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27973 }
27974 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27975 {
27976 PyThreadState* __tstate = wxPyBeginAllowThreads();
27977 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
27978 wxPyEndAllowThreads(__tstate);
27979 if (PyErr_Occurred()) SWIG_fail;
27980 }
27981 {
27982 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27983 }
27984 return resultobj;
27985 fail:
27986 return NULL;
27987 }
27988
27989
27990 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27991 PyObject *resultobj = 0;
27992 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27993 bool result;
27994 void *argp1 = 0 ;
27995 int res1 = 0 ;
27996 PyObject *swig_obj[1] ;
27997
27998 if (!args) SWIG_fail;
27999 swig_obj[0] = args;
28000 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28001 if (!SWIG_IsOK(res1)) {
28002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
28003 }
28004 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28005 {
28006 PyThreadState* __tstate = wxPyBeginAllowThreads();
28007 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
28008 wxPyEndAllowThreads(__tstate);
28009 if (PyErr_Occurred()) SWIG_fail;
28010 }
28011 {
28012 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28013 }
28014 return resultobj;
28015 fail:
28016 return NULL;
28017 }
28018
28019
28020 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28021 PyObject *resultobj = 0;
28022 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28023 bool arg2 ;
28024 void *argp1 = 0 ;
28025 int res1 = 0 ;
28026 bool val2 ;
28027 int ecode2 = 0 ;
28028 PyObject * obj0 = 0 ;
28029 PyObject * obj1 = 0 ;
28030 char * kwnames[] = {
28031 (char *) "self",(char *) "check", NULL
28032 };
28033
28034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
28035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28036 if (!SWIG_IsOK(res1)) {
28037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28038 }
28039 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28040 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28041 if (!SWIG_IsOK(ecode2)) {
28042 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
28043 }
28044 arg2 = static_cast< bool >(val2);
28045 {
28046 PyThreadState* __tstate = wxPyBeginAllowThreads();
28047 (arg1)->Check(arg2);
28048 wxPyEndAllowThreads(__tstate);
28049 if (PyErr_Occurred()) SWIG_fail;
28050 }
28051 resultobj = SWIG_Py_Void();
28052 return resultobj;
28053 fail:
28054 return NULL;
28055 }
28056
28057
28058 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28059 PyObject *resultobj = 0;
28060 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28061 bool arg2 ;
28062 void *argp1 = 0 ;
28063 int res1 = 0 ;
28064 bool val2 ;
28065 int ecode2 = 0 ;
28066 PyObject * obj0 = 0 ;
28067 PyObject * obj1 = 0 ;
28068 char * kwnames[] = {
28069 (char *) "self",(char *) "enable", NULL
28070 };
28071
28072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
28073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28074 if (!SWIG_IsOK(res1)) {
28075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28076 }
28077 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28078 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28079 if (!SWIG_IsOK(ecode2)) {
28080 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
28081 }
28082 arg2 = static_cast< bool >(val2);
28083 {
28084 PyThreadState* __tstate = wxPyBeginAllowThreads();
28085 (arg1)->Enable(arg2);
28086 wxPyEndAllowThreads(__tstate);
28087 if (PyErr_Occurred()) SWIG_fail;
28088 }
28089 resultobj = SWIG_Py_Void();
28090 return resultobj;
28091 fail:
28092 return NULL;
28093 }
28094
28095
28096 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28097 PyObject *resultobj = 0;
28098 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28099 bool arg2 ;
28100 void *argp1 = 0 ;
28101 int res1 = 0 ;
28102 bool val2 ;
28103 int ecode2 = 0 ;
28104 PyObject * obj0 = 0 ;
28105 PyObject * obj1 = 0 ;
28106 char * kwnames[] = {
28107 (char *) "self",(char *) "show", NULL
28108 };
28109
28110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
28111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28112 if (!SWIG_IsOK(res1)) {
28113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28114 }
28115 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28116 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28117 if (!SWIG_IsOK(ecode2)) {
28118 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
28119 }
28120 arg2 = static_cast< bool >(val2);
28121 {
28122 PyThreadState* __tstate = wxPyBeginAllowThreads();
28123 (arg1)->Show(arg2);
28124 wxPyEndAllowThreads(__tstate);
28125 if (PyErr_Occurred()) SWIG_fail;
28126 }
28127 resultobj = SWIG_Py_Void();
28128 return resultobj;
28129 fail:
28130 return NULL;
28131 }
28132
28133
28134 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28135 PyObject *resultobj = 0;
28136 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28137 wxString *arg2 = 0 ;
28138 void *argp1 = 0 ;
28139 int res1 = 0 ;
28140 bool temp2 = false ;
28141 PyObject * obj0 = 0 ;
28142 PyObject * obj1 = 0 ;
28143 char * kwnames[] = {
28144 (char *) "self",(char *) "text", NULL
28145 };
28146
28147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
28148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28149 if (!SWIG_IsOK(res1)) {
28150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28151 }
28152 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28153 {
28154 arg2 = wxString_in_helper(obj1);
28155 if (arg2 == NULL) SWIG_fail;
28156 temp2 = true;
28157 }
28158 {
28159 PyThreadState* __tstate = wxPyBeginAllowThreads();
28160 (arg1)->SetText((wxString const &)*arg2);
28161 wxPyEndAllowThreads(__tstate);
28162 if (PyErr_Occurred()) SWIG_fail;
28163 }
28164 resultobj = SWIG_Py_Void();
28165 {
28166 if (temp2)
28167 delete arg2;
28168 }
28169 return resultobj;
28170 fail:
28171 {
28172 if (temp2)
28173 delete arg2;
28174 }
28175 return NULL;
28176 }
28177
28178
28179 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28180 PyObject *resultobj = 0;
28181 long arg1 ;
28182 long val1 ;
28183 int ecode1 = 0 ;
28184 PyObject * obj0 = 0 ;
28185 char * kwnames[] = {
28186 (char *) "updateInterval", NULL
28187 };
28188
28189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
28190 ecode1 = SWIG_AsVal_long(obj0, &val1);
28191 if (!SWIG_IsOK(ecode1)) {
28192 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
28193 }
28194 arg1 = static_cast< long >(val1);
28195 {
28196 PyThreadState* __tstate = wxPyBeginAllowThreads();
28197 wxUpdateUIEvent::SetUpdateInterval(arg1);
28198 wxPyEndAllowThreads(__tstate);
28199 if (PyErr_Occurred()) SWIG_fail;
28200 }
28201 resultobj = SWIG_Py_Void();
28202 return resultobj;
28203 fail:
28204 return NULL;
28205 }
28206
28207
28208 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28209 PyObject *resultobj = 0;
28210 long result;
28211
28212 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
28213 {
28214 PyThreadState* __tstate = wxPyBeginAllowThreads();
28215 result = (long)wxUpdateUIEvent::GetUpdateInterval();
28216 wxPyEndAllowThreads(__tstate);
28217 if (PyErr_Occurred()) SWIG_fail;
28218 }
28219 resultobj = SWIG_From_long(static_cast< long >(result));
28220 return resultobj;
28221 fail:
28222 return NULL;
28223 }
28224
28225
28226 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28227 PyObject *resultobj = 0;
28228 wxWindow *arg1 = (wxWindow *) 0 ;
28229 bool result;
28230 void *argp1 = 0 ;
28231 int res1 = 0 ;
28232 PyObject * obj0 = 0 ;
28233 char * kwnames[] = {
28234 (char *) "win", NULL
28235 };
28236
28237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
28238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28239 if (!SWIG_IsOK(res1)) {
28240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
28241 }
28242 arg1 = reinterpret_cast< wxWindow * >(argp1);
28243 {
28244 PyThreadState* __tstate = wxPyBeginAllowThreads();
28245 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
28246 wxPyEndAllowThreads(__tstate);
28247 if (PyErr_Occurred()) SWIG_fail;
28248 }
28249 {
28250 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28251 }
28252 return resultobj;
28253 fail:
28254 return NULL;
28255 }
28256
28257
28258 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28259 PyObject *resultobj = 0;
28260
28261 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
28262 {
28263 PyThreadState* __tstate = wxPyBeginAllowThreads();
28264 wxUpdateUIEvent::ResetUpdateTime();
28265 wxPyEndAllowThreads(__tstate);
28266 if (PyErr_Occurred()) SWIG_fail;
28267 }
28268 resultobj = SWIG_Py_Void();
28269 return resultobj;
28270 fail:
28271 return NULL;
28272 }
28273
28274
28275 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28276 PyObject *resultobj = 0;
28277 wxUpdateUIMode arg1 ;
28278 int val1 ;
28279 int ecode1 = 0 ;
28280 PyObject * obj0 = 0 ;
28281 char * kwnames[] = {
28282 (char *) "mode", NULL
28283 };
28284
28285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
28286 ecode1 = SWIG_AsVal_int(obj0, &val1);
28287 if (!SWIG_IsOK(ecode1)) {
28288 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
28289 }
28290 arg1 = static_cast< wxUpdateUIMode >(val1);
28291 {
28292 PyThreadState* __tstate = wxPyBeginAllowThreads();
28293 wxUpdateUIEvent::SetMode(arg1);
28294 wxPyEndAllowThreads(__tstate);
28295 if (PyErr_Occurred()) SWIG_fail;
28296 }
28297 resultobj = SWIG_Py_Void();
28298 return resultobj;
28299 fail:
28300 return NULL;
28301 }
28302
28303
28304 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28305 PyObject *resultobj = 0;
28306 wxUpdateUIMode result;
28307
28308 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
28309 {
28310 PyThreadState* __tstate = wxPyBeginAllowThreads();
28311 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
28312 wxPyEndAllowThreads(__tstate);
28313 if (PyErr_Occurred()) SWIG_fail;
28314 }
28315 resultobj = SWIG_From_int(static_cast< int >(result));
28316 return resultobj;
28317 fail:
28318 return NULL;
28319 }
28320
28321
28322 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28323 PyObject *obj;
28324 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28325 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
28326 return SWIG_Py_Void();
28327 }
28328
28329 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28330 return SWIG_Python_InitShadowInstance(args);
28331 }
28332
28333 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28334 PyObject *resultobj = 0;
28335 wxSysColourChangedEvent *result = 0 ;
28336
28337 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
28338 {
28339 PyThreadState* __tstate = wxPyBeginAllowThreads();
28340 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
28341 wxPyEndAllowThreads(__tstate);
28342 if (PyErr_Occurred()) SWIG_fail;
28343 }
28344 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
28345 return resultobj;
28346 fail:
28347 return NULL;
28348 }
28349
28350
28351 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28352 PyObject *obj;
28353 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28354 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
28355 return SWIG_Py_Void();
28356 }
28357
28358 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28359 return SWIG_Python_InitShadowInstance(args);
28360 }
28361
28362 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28363 PyObject *resultobj = 0;
28364 int arg1 = (int) 0 ;
28365 wxWindow *arg2 = (wxWindow *) NULL ;
28366 wxMouseCaptureChangedEvent *result = 0 ;
28367 int val1 ;
28368 int ecode1 = 0 ;
28369 void *argp2 = 0 ;
28370 int res2 = 0 ;
28371 PyObject * obj0 = 0 ;
28372 PyObject * obj1 = 0 ;
28373 char * kwnames[] = {
28374 (char *) "winid",(char *) "gainedCapture", NULL
28375 };
28376
28377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28378 if (obj0) {
28379 ecode1 = SWIG_AsVal_int(obj0, &val1);
28380 if (!SWIG_IsOK(ecode1)) {
28381 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
28382 }
28383 arg1 = static_cast< int >(val1);
28384 }
28385 if (obj1) {
28386 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28387 if (!SWIG_IsOK(res2)) {
28388 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
28389 }
28390 arg2 = reinterpret_cast< wxWindow * >(argp2);
28391 }
28392 {
28393 PyThreadState* __tstate = wxPyBeginAllowThreads();
28394 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
28395 wxPyEndAllowThreads(__tstate);
28396 if (PyErr_Occurred()) SWIG_fail;
28397 }
28398 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
28399 return resultobj;
28400 fail:
28401 return NULL;
28402 }
28403
28404
28405 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28406 PyObject *resultobj = 0;
28407 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
28408 wxWindow *result = 0 ;
28409 void *argp1 = 0 ;
28410 int res1 = 0 ;
28411 PyObject *swig_obj[1] ;
28412
28413 if (!args) SWIG_fail;
28414 swig_obj[0] = args;
28415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
28416 if (!SWIG_IsOK(res1)) {
28417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
28418 }
28419 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
28420 {
28421 PyThreadState* __tstate = wxPyBeginAllowThreads();
28422 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
28423 wxPyEndAllowThreads(__tstate);
28424 if (PyErr_Occurred()) SWIG_fail;
28425 }
28426 {
28427 resultobj = wxPyMake_wxObject(result, (bool)0);
28428 }
28429 return resultobj;
28430 fail:
28431 return NULL;
28432 }
28433
28434
28435 SWIGINTERN PyObject *MouseCaptureChangedEvent_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_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
28439 return SWIG_Py_Void();
28440 }
28441
28442 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28443 return SWIG_Python_InitShadowInstance(args);
28444 }
28445
28446 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28447 PyObject *resultobj = 0;
28448 int arg1 = (int) 0 ;
28449 wxMouseCaptureLostEvent *result = 0 ;
28450 int val1 ;
28451 int ecode1 = 0 ;
28452 PyObject * obj0 = 0 ;
28453 char * kwnames[] = {
28454 (char *) "winid", NULL
28455 };
28456
28457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",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_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
28462 }
28463 arg1 = static_cast< int >(val1);
28464 }
28465 {
28466 PyThreadState* __tstate = wxPyBeginAllowThreads();
28467 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
28468 wxPyEndAllowThreads(__tstate);
28469 if (PyErr_Occurred()) SWIG_fail;
28470 }
28471 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
28472 return resultobj;
28473 fail:
28474 return NULL;
28475 }
28476
28477
28478 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28479 PyObject *obj;
28480 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28481 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
28482 return SWIG_Py_Void();
28483 }
28484
28485 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28486 return SWIG_Python_InitShadowInstance(args);
28487 }
28488
28489 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28490 PyObject *resultobj = 0;
28491 wxDisplayChangedEvent *result = 0 ;
28492
28493 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
28494 {
28495 PyThreadState* __tstate = wxPyBeginAllowThreads();
28496 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
28497 wxPyEndAllowThreads(__tstate);
28498 if (PyErr_Occurred()) SWIG_fail;
28499 }
28500 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
28501 return resultobj;
28502 fail:
28503 return NULL;
28504 }
28505
28506
28507 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28508 PyObject *obj;
28509 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28510 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
28511 return SWIG_Py_Void();
28512 }
28513
28514 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28515 return SWIG_Python_InitShadowInstance(args);
28516 }
28517
28518 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28519 PyObject *resultobj = 0;
28520 int arg1 = (int) 0 ;
28521 wxPaletteChangedEvent *result = 0 ;
28522 int val1 ;
28523 int ecode1 = 0 ;
28524 PyObject * obj0 = 0 ;
28525 char * kwnames[] = {
28526 (char *) "id", NULL
28527 };
28528
28529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
28530 if (obj0) {
28531 ecode1 = SWIG_AsVal_int(obj0, &val1);
28532 if (!SWIG_IsOK(ecode1)) {
28533 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
28534 }
28535 arg1 = static_cast< int >(val1);
28536 }
28537 {
28538 PyThreadState* __tstate = wxPyBeginAllowThreads();
28539 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
28540 wxPyEndAllowThreads(__tstate);
28541 if (PyErr_Occurred()) SWIG_fail;
28542 }
28543 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
28544 return resultobj;
28545 fail:
28546 return NULL;
28547 }
28548
28549
28550 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28551 PyObject *resultobj = 0;
28552 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
28553 wxWindow *arg2 = (wxWindow *) 0 ;
28554 void *argp1 = 0 ;
28555 int res1 = 0 ;
28556 void *argp2 = 0 ;
28557 int res2 = 0 ;
28558 PyObject * obj0 = 0 ;
28559 PyObject * obj1 = 0 ;
28560 char * kwnames[] = {
28561 (char *) "self",(char *) "win", NULL
28562 };
28563
28564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
28565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
28566 if (!SWIG_IsOK(res1)) {
28567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
28568 }
28569 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
28570 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28571 if (!SWIG_IsOK(res2)) {
28572 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
28573 }
28574 arg2 = reinterpret_cast< wxWindow * >(argp2);
28575 {
28576 PyThreadState* __tstate = wxPyBeginAllowThreads();
28577 (arg1)->SetChangedWindow(arg2);
28578 wxPyEndAllowThreads(__tstate);
28579 if (PyErr_Occurred()) SWIG_fail;
28580 }
28581 resultobj = SWIG_Py_Void();
28582 return resultobj;
28583 fail:
28584 return NULL;
28585 }
28586
28587
28588 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28589 PyObject *resultobj = 0;
28590 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
28591 wxWindow *result = 0 ;
28592 void *argp1 = 0 ;
28593 int res1 = 0 ;
28594 PyObject *swig_obj[1] ;
28595
28596 if (!args) SWIG_fail;
28597 swig_obj[0] = args;
28598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
28599 if (!SWIG_IsOK(res1)) {
28600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
28601 }
28602 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
28603 {
28604 PyThreadState* __tstate = wxPyBeginAllowThreads();
28605 result = (wxWindow *)(arg1)->GetChangedWindow();
28606 wxPyEndAllowThreads(__tstate);
28607 if (PyErr_Occurred()) SWIG_fail;
28608 }
28609 {
28610 resultobj = wxPyMake_wxObject(result, (bool)0);
28611 }
28612 return resultobj;
28613 fail:
28614 return NULL;
28615 }
28616
28617
28618 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28619 PyObject *obj;
28620 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28621 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
28622 return SWIG_Py_Void();
28623 }
28624
28625 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28626 return SWIG_Python_InitShadowInstance(args);
28627 }
28628
28629 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28630 PyObject *resultobj = 0;
28631 int arg1 = (int) 0 ;
28632 wxQueryNewPaletteEvent *result = 0 ;
28633 int val1 ;
28634 int ecode1 = 0 ;
28635 PyObject * obj0 = 0 ;
28636 char * kwnames[] = {
28637 (char *) "winid", NULL
28638 };
28639
28640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
28641 if (obj0) {
28642 ecode1 = SWIG_AsVal_int(obj0, &val1);
28643 if (!SWIG_IsOK(ecode1)) {
28644 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
28645 }
28646 arg1 = static_cast< int >(val1);
28647 }
28648 {
28649 PyThreadState* __tstate = wxPyBeginAllowThreads();
28650 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
28651 wxPyEndAllowThreads(__tstate);
28652 if (PyErr_Occurred()) SWIG_fail;
28653 }
28654 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
28655 return resultobj;
28656 fail:
28657 return NULL;
28658 }
28659
28660
28661 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28662 PyObject *resultobj = 0;
28663 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
28664 bool arg2 ;
28665 void *argp1 = 0 ;
28666 int res1 = 0 ;
28667 bool val2 ;
28668 int ecode2 = 0 ;
28669 PyObject * obj0 = 0 ;
28670 PyObject * obj1 = 0 ;
28671 char * kwnames[] = {
28672 (char *) "self",(char *) "realized", NULL
28673 };
28674
28675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
28676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
28677 if (!SWIG_IsOK(res1)) {
28678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
28679 }
28680 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
28681 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28682 if (!SWIG_IsOK(ecode2)) {
28683 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
28684 }
28685 arg2 = static_cast< bool >(val2);
28686 {
28687 PyThreadState* __tstate = wxPyBeginAllowThreads();
28688 (arg1)->SetPaletteRealized(arg2);
28689 wxPyEndAllowThreads(__tstate);
28690 if (PyErr_Occurred()) SWIG_fail;
28691 }
28692 resultobj = SWIG_Py_Void();
28693 return resultobj;
28694 fail:
28695 return NULL;
28696 }
28697
28698
28699 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28700 PyObject *resultobj = 0;
28701 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
28702 bool result;
28703 void *argp1 = 0 ;
28704 int res1 = 0 ;
28705 PyObject *swig_obj[1] ;
28706
28707 if (!args) SWIG_fail;
28708 swig_obj[0] = args;
28709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
28710 if (!SWIG_IsOK(res1)) {
28711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
28712 }
28713 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
28714 {
28715 PyThreadState* __tstate = wxPyBeginAllowThreads();
28716 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
28717 wxPyEndAllowThreads(__tstate);
28718 if (PyErr_Occurred()) SWIG_fail;
28719 }
28720 {
28721 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28722 }
28723 return resultobj;
28724 fail:
28725 return NULL;
28726 }
28727
28728
28729 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28730 PyObject *obj;
28731 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28732 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
28733 return SWIG_Py_Void();
28734 }
28735
28736 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28737 return SWIG_Python_InitShadowInstance(args);
28738 }
28739
28740 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28741 PyObject *resultobj = 0;
28742 wxNavigationKeyEvent *result = 0 ;
28743
28744 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
28745 {
28746 PyThreadState* __tstate = wxPyBeginAllowThreads();
28747 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
28748 wxPyEndAllowThreads(__tstate);
28749 if (PyErr_Occurred()) SWIG_fail;
28750 }
28751 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
28752 return resultobj;
28753 fail:
28754 return NULL;
28755 }
28756
28757
28758 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28759 PyObject *resultobj = 0;
28760 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28761 bool result;
28762 void *argp1 = 0 ;
28763 int res1 = 0 ;
28764 PyObject *swig_obj[1] ;
28765
28766 if (!args) SWIG_fail;
28767 swig_obj[0] = args;
28768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28769 if (!SWIG_IsOK(res1)) {
28770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28771 }
28772 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28773 {
28774 PyThreadState* __tstate = wxPyBeginAllowThreads();
28775 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
28776 wxPyEndAllowThreads(__tstate);
28777 if (PyErr_Occurred()) SWIG_fail;
28778 }
28779 {
28780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28781 }
28782 return resultobj;
28783 fail:
28784 return NULL;
28785 }
28786
28787
28788 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28789 PyObject *resultobj = 0;
28790 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28791 bool arg2 ;
28792 void *argp1 = 0 ;
28793 int res1 = 0 ;
28794 bool val2 ;
28795 int ecode2 = 0 ;
28796 PyObject * obj0 = 0 ;
28797 PyObject * obj1 = 0 ;
28798 char * kwnames[] = {
28799 (char *) "self",(char *) "forward", NULL
28800 };
28801
28802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
28803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28804 if (!SWIG_IsOK(res1)) {
28805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28806 }
28807 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28808 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28809 if (!SWIG_IsOK(ecode2)) {
28810 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
28811 }
28812 arg2 = static_cast< bool >(val2);
28813 {
28814 PyThreadState* __tstate = wxPyBeginAllowThreads();
28815 (arg1)->SetDirection(arg2);
28816 wxPyEndAllowThreads(__tstate);
28817 if (PyErr_Occurred()) SWIG_fail;
28818 }
28819 resultobj = SWIG_Py_Void();
28820 return resultobj;
28821 fail:
28822 return NULL;
28823 }
28824
28825
28826 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28827 PyObject *resultobj = 0;
28828 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28829 bool result;
28830 void *argp1 = 0 ;
28831 int res1 = 0 ;
28832 PyObject *swig_obj[1] ;
28833
28834 if (!args) SWIG_fail;
28835 swig_obj[0] = args;
28836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28837 if (!SWIG_IsOK(res1)) {
28838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28839 }
28840 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28841 {
28842 PyThreadState* __tstate = wxPyBeginAllowThreads();
28843 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
28844 wxPyEndAllowThreads(__tstate);
28845 if (PyErr_Occurred()) SWIG_fail;
28846 }
28847 {
28848 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28849 }
28850 return resultobj;
28851 fail:
28852 return NULL;
28853 }
28854
28855
28856 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28857 PyObject *resultobj = 0;
28858 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28859 bool arg2 ;
28860 void *argp1 = 0 ;
28861 int res1 = 0 ;
28862 bool val2 ;
28863 int ecode2 = 0 ;
28864 PyObject * obj0 = 0 ;
28865 PyObject * obj1 = 0 ;
28866 char * kwnames[] = {
28867 (char *) "self",(char *) "ischange", NULL
28868 };
28869
28870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
28871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28872 if (!SWIG_IsOK(res1)) {
28873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28874 }
28875 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28876 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28877 if (!SWIG_IsOK(ecode2)) {
28878 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
28879 }
28880 arg2 = static_cast< bool >(val2);
28881 {
28882 PyThreadState* __tstate = wxPyBeginAllowThreads();
28883 (arg1)->SetWindowChange(arg2);
28884 wxPyEndAllowThreads(__tstate);
28885 if (PyErr_Occurred()) SWIG_fail;
28886 }
28887 resultobj = SWIG_Py_Void();
28888 return resultobj;
28889 fail:
28890 return NULL;
28891 }
28892
28893
28894 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28895 PyObject *resultobj = 0;
28896 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28897 bool result;
28898 void *argp1 = 0 ;
28899 int res1 = 0 ;
28900 PyObject *swig_obj[1] ;
28901
28902 if (!args) SWIG_fail;
28903 swig_obj[0] = args;
28904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28905 if (!SWIG_IsOK(res1)) {
28906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28907 }
28908 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28909 {
28910 PyThreadState* __tstate = wxPyBeginAllowThreads();
28911 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
28912 wxPyEndAllowThreads(__tstate);
28913 if (PyErr_Occurred()) SWIG_fail;
28914 }
28915 {
28916 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28917 }
28918 return resultobj;
28919 fail:
28920 return NULL;
28921 }
28922
28923
28924 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28925 PyObject *resultobj = 0;
28926 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28927 bool arg2 ;
28928 void *argp1 = 0 ;
28929 int res1 = 0 ;
28930 bool val2 ;
28931 int ecode2 = 0 ;
28932 PyObject * obj0 = 0 ;
28933 PyObject * obj1 = 0 ;
28934 char * kwnames[] = {
28935 (char *) "self",(char *) "bIs", NULL
28936 };
28937
28938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
28939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28940 if (!SWIG_IsOK(res1)) {
28941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28942 }
28943 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28944 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28945 if (!SWIG_IsOK(ecode2)) {
28946 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
28947 }
28948 arg2 = static_cast< bool >(val2);
28949 {
28950 PyThreadState* __tstate = wxPyBeginAllowThreads();
28951 (arg1)->SetFromTab(arg2);
28952 wxPyEndAllowThreads(__tstate);
28953 if (PyErr_Occurred()) SWIG_fail;
28954 }
28955 resultobj = SWIG_Py_Void();
28956 return resultobj;
28957 fail:
28958 return NULL;
28959 }
28960
28961
28962 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28963 PyObject *resultobj = 0;
28964 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28965 long arg2 ;
28966 void *argp1 = 0 ;
28967 int res1 = 0 ;
28968 long val2 ;
28969 int ecode2 = 0 ;
28970 PyObject * obj0 = 0 ;
28971 PyObject * obj1 = 0 ;
28972 char * kwnames[] = {
28973 (char *) "self",(char *) "flags", NULL
28974 };
28975
28976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
28977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28978 if (!SWIG_IsOK(res1)) {
28979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28980 }
28981 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28982 ecode2 = SWIG_AsVal_long(obj1, &val2);
28983 if (!SWIG_IsOK(ecode2)) {
28984 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
28985 }
28986 arg2 = static_cast< long >(val2);
28987 {
28988 PyThreadState* __tstate = wxPyBeginAllowThreads();
28989 (arg1)->SetFlags(arg2);
28990 wxPyEndAllowThreads(__tstate);
28991 if (PyErr_Occurred()) SWIG_fail;
28992 }
28993 resultobj = SWIG_Py_Void();
28994 return resultobj;
28995 fail:
28996 return NULL;
28997 }
28998
28999
29000 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29001 PyObject *resultobj = 0;
29002 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
29003 wxWindow *result = 0 ;
29004 void *argp1 = 0 ;
29005 int res1 = 0 ;
29006 PyObject *swig_obj[1] ;
29007
29008 if (!args) SWIG_fail;
29009 swig_obj[0] = args;
29010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
29011 if (!SWIG_IsOK(res1)) {
29012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
29013 }
29014 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29015 {
29016 PyThreadState* __tstate = wxPyBeginAllowThreads();
29017 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
29018 wxPyEndAllowThreads(__tstate);
29019 if (PyErr_Occurred()) SWIG_fail;
29020 }
29021 {
29022 resultobj = wxPyMake_wxObject(result, (bool)0);
29023 }
29024 return resultobj;
29025 fail:
29026 return NULL;
29027 }
29028
29029
29030 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29031 PyObject *resultobj = 0;
29032 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
29033 wxWindow *arg2 = (wxWindow *) 0 ;
29034 void *argp1 = 0 ;
29035 int res1 = 0 ;
29036 void *argp2 = 0 ;
29037 int res2 = 0 ;
29038 PyObject * obj0 = 0 ;
29039 PyObject * obj1 = 0 ;
29040 char * kwnames[] = {
29041 (char *) "self",(char *) "win", NULL
29042 };
29043
29044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
29045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
29046 if (!SWIG_IsOK(res1)) {
29047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
29048 }
29049 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29050 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29051 if (!SWIG_IsOK(res2)) {
29052 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
29053 }
29054 arg2 = reinterpret_cast< wxWindow * >(argp2);
29055 {
29056 PyThreadState* __tstate = wxPyBeginAllowThreads();
29057 (arg1)->SetCurrentFocus(arg2);
29058 wxPyEndAllowThreads(__tstate);
29059 if (PyErr_Occurred()) SWIG_fail;
29060 }
29061 resultobj = SWIG_Py_Void();
29062 return resultobj;
29063 fail:
29064 return NULL;
29065 }
29066
29067
29068 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29069 PyObject *obj;
29070 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29071 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
29072 return SWIG_Py_Void();
29073 }
29074
29075 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29076 return SWIG_Python_InitShadowInstance(args);
29077 }
29078
29079 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29080 PyObject *resultobj = 0;
29081 wxWindow *arg1 = (wxWindow *) NULL ;
29082 wxWindowCreateEvent *result = 0 ;
29083 void *argp1 = 0 ;
29084 int res1 = 0 ;
29085 PyObject * obj0 = 0 ;
29086 char * kwnames[] = {
29087 (char *) "win", NULL
29088 };
29089
29090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
29091 if (obj0) {
29092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29093 if (!SWIG_IsOK(res1)) {
29094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29095 }
29096 arg1 = reinterpret_cast< wxWindow * >(argp1);
29097 }
29098 {
29099 PyThreadState* __tstate = wxPyBeginAllowThreads();
29100 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
29101 wxPyEndAllowThreads(__tstate);
29102 if (PyErr_Occurred()) SWIG_fail;
29103 }
29104 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
29105 return resultobj;
29106 fail:
29107 return NULL;
29108 }
29109
29110
29111 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29112 PyObject *resultobj = 0;
29113 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
29114 wxWindow *result = 0 ;
29115 void *argp1 = 0 ;
29116 int res1 = 0 ;
29117 PyObject *swig_obj[1] ;
29118
29119 if (!args) SWIG_fail;
29120 swig_obj[0] = args;
29121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
29122 if (!SWIG_IsOK(res1)) {
29123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
29124 }
29125 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
29126 {
29127 PyThreadState* __tstate = wxPyBeginAllowThreads();
29128 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
29129 wxPyEndAllowThreads(__tstate);
29130 if (PyErr_Occurred()) SWIG_fail;
29131 }
29132 {
29133 resultobj = wxPyMake_wxObject(result, (bool)0);
29134 }
29135 return resultobj;
29136 fail:
29137 return NULL;
29138 }
29139
29140
29141 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29142 PyObject *obj;
29143 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29144 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
29145 return SWIG_Py_Void();
29146 }
29147
29148 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29149 return SWIG_Python_InitShadowInstance(args);
29150 }
29151
29152 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29153 PyObject *resultobj = 0;
29154 wxWindow *arg1 = (wxWindow *) NULL ;
29155 wxWindowDestroyEvent *result = 0 ;
29156 void *argp1 = 0 ;
29157 int res1 = 0 ;
29158 PyObject * obj0 = 0 ;
29159 char * kwnames[] = {
29160 (char *) "win", NULL
29161 };
29162
29163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
29164 if (obj0) {
29165 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29166 if (!SWIG_IsOK(res1)) {
29167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29168 }
29169 arg1 = reinterpret_cast< wxWindow * >(argp1);
29170 }
29171 {
29172 PyThreadState* __tstate = wxPyBeginAllowThreads();
29173 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
29174 wxPyEndAllowThreads(__tstate);
29175 if (PyErr_Occurred()) SWIG_fail;
29176 }
29177 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
29178 return resultobj;
29179 fail:
29180 return NULL;
29181 }
29182
29183
29184 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29185 PyObject *resultobj = 0;
29186 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
29187 wxWindow *result = 0 ;
29188 void *argp1 = 0 ;
29189 int res1 = 0 ;
29190 PyObject *swig_obj[1] ;
29191
29192 if (!args) SWIG_fail;
29193 swig_obj[0] = args;
29194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
29195 if (!SWIG_IsOK(res1)) {
29196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
29197 }
29198 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
29199 {
29200 PyThreadState* __tstate = wxPyBeginAllowThreads();
29201 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
29202 wxPyEndAllowThreads(__tstate);
29203 if (PyErr_Occurred()) SWIG_fail;
29204 }
29205 {
29206 resultobj = wxPyMake_wxObject(result, (bool)0);
29207 }
29208 return resultobj;
29209 fail:
29210 return NULL;
29211 }
29212
29213
29214 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29215 PyObject *obj;
29216 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29217 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
29218 return SWIG_Py_Void();
29219 }
29220
29221 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29222 return SWIG_Python_InitShadowInstance(args);
29223 }
29224
29225 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29226 PyObject *resultobj = 0;
29227 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29228 int arg2 = (int) 0 ;
29229 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29230 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29231 wxContextMenuEvent *result = 0 ;
29232 int val1 ;
29233 int ecode1 = 0 ;
29234 int val2 ;
29235 int ecode2 = 0 ;
29236 wxPoint temp3 ;
29237 PyObject * obj0 = 0 ;
29238 PyObject * obj1 = 0 ;
29239 PyObject * obj2 = 0 ;
29240 char * kwnames[] = {
29241 (char *) "type",(char *) "winid",(char *) "pt", NULL
29242 };
29243
29244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29245 if (obj0) {
29246 ecode1 = SWIG_AsVal_int(obj0, &val1);
29247 if (!SWIG_IsOK(ecode1)) {
29248 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29249 }
29250 arg1 = static_cast< wxEventType >(val1);
29251 }
29252 if (obj1) {
29253 ecode2 = SWIG_AsVal_int(obj1, &val2);
29254 if (!SWIG_IsOK(ecode2)) {
29255 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
29256 }
29257 arg2 = static_cast< int >(val2);
29258 }
29259 if (obj2) {
29260 {
29261 arg3 = &temp3;
29262 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29263 }
29264 }
29265 {
29266 PyThreadState* __tstate = wxPyBeginAllowThreads();
29267 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
29268 wxPyEndAllowThreads(__tstate);
29269 if (PyErr_Occurred()) SWIG_fail;
29270 }
29271 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
29272 return resultobj;
29273 fail:
29274 return NULL;
29275 }
29276
29277
29278 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29279 PyObject *resultobj = 0;
29280 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
29281 wxPoint *result = 0 ;
29282 void *argp1 = 0 ;
29283 int res1 = 0 ;
29284 PyObject *swig_obj[1] ;
29285
29286 if (!args) SWIG_fail;
29287 swig_obj[0] = args;
29288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
29289 if (!SWIG_IsOK(res1)) {
29290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
29291 }
29292 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
29293 {
29294 PyThreadState* __tstate = wxPyBeginAllowThreads();
29295 {
29296 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
29297 result = (wxPoint *) &_result_ref;
29298 }
29299 wxPyEndAllowThreads(__tstate);
29300 if (PyErr_Occurred()) SWIG_fail;
29301 }
29302 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
29303 return resultobj;
29304 fail:
29305 return NULL;
29306 }
29307
29308
29309 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29310 PyObject *resultobj = 0;
29311 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
29312 wxPoint *arg2 = 0 ;
29313 void *argp1 = 0 ;
29314 int res1 = 0 ;
29315 wxPoint temp2 ;
29316 PyObject * obj0 = 0 ;
29317 PyObject * obj1 = 0 ;
29318 char * kwnames[] = {
29319 (char *) "self",(char *) "pos", NULL
29320 };
29321
29322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
29323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
29324 if (!SWIG_IsOK(res1)) {
29325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
29326 }
29327 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
29328 {
29329 arg2 = &temp2;
29330 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29331 }
29332 {
29333 PyThreadState* __tstate = wxPyBeginAllowThreads();
29334 (arg1)->SetPosition((wxPoint const &)*arg2);
29335 wxPyEndAllowThreads(__tstate);
29336 if (PyErr_Occurred()) SWIG_fail;
29337 }
29338 resultobj = SWIG_Py_Void();
29339 return resultobj;
29340 fail:
29341 return NULL;
29342 }
29343
29344
29345 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29346 PyObject *obj;
29347 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29348 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
29349 return SWIG_Py_Void();
29350 }
29351
29352 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29353 return SWIG_Python_InitShadowInstance(args);
29354 }
29355
29356 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29357 PyObject *resultobj = 0;
29358 wxIdleEvent *result = 0 ;
29359
29360 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
29361 {
29362 PyThreadState* __tstate = wxPyBeginAllowThreads();
29363 result = (wxIdleEvent *)new wxIdleEvent();
29364 wxPyEndAllowThreads(__tstate);
29365 if (PyErr_Occurred()) SWIG_fail;
29366 }
29367 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
29368 return resultobj;
29369 fail:
29370 return NULL;
29371 }
29372
29373
29374 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29375 PyObject *resultobj = 0;
29376 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
29377 bool arg2 = (bool) true ;
29378 void *argp1 = 0 ;
29379 int res1 = 0 ;
29380 bool val2 ;
29381 int ecode2 = 0 ;
29382 PyObject * obj0 = 0 ;
29383 PyObject * obj1 = 0 ;
29384 char * kwnames[] = {
29385 (char *) "self",(char *) "needMore", NULL
29386 };
29387
29388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
29389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
29390 if (!SWIG_IsOK(res1)) {
29391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
29392 }
29393 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
29394 if (obj1) {
29395 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29396 if (!SWIG_IsOK(ecode2)) {
29397 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
29398 }
29399 arg2 = static_cast< bool >(val2);
29400 }
29401 {
29402 PyThreadState* __tstate = wxPyBeginAllowThreads();
29403 (arg1)->RequestMore(arg2);
29404 wxPyEndAllowThreads(__tstate);
29405 if (PyErr_Occurred()) SWIG_fail;
29406 }
29407 resultobj = SWIG_Py_Void();
29408 return resultobj;
29409 fail:
29410 return NULL;
29411 }
29412
29413
29414 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29415 PyObject *resultobj = 0;
29416 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
29417 bool result;
29418 void *argp1 = 0 ;
29419 int res1 = 0 ;
29420 PyObject *swig_obj[1] ;
29421
29422 if (!args) SWIG_fail;
29423 swig_obj[0] = args;
29424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
29425 if (!SWIG_IsOK(res1)) {
29426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
29427 }
29428 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
29429 {
29430 PyThreadState* __tstate = wxPyBeginAllowThreads();
29431 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
29432 wxPyEndAllowThreads(__tstate);
29433 if (PyErr_Occurred()) SWIG_fail;
29434 }
29435 {
29436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29437 }
29438 return resultobj;
29439 fail:
29440 return NULL;
29441 }
29442
29443
29444 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29445 PyObject *resultobj = 0;
29446 wxIdleMode arg1 ;
29447 int val1 ;
29448 int ecode1 = 0 ;
29449 PyObject * obj0 = 0 ;
29450 char * kwnames[] = {
29451 (char *) "mode", NULL
29452 };
29453
29454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
29455 ecode1 = SWIG_AsVal_int(obj0, &val1);
29456 if (!SWIG_IsOK(ecode1)) {
29457 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
29458 }
29459 arg1 = static_cast< wxIdleMode >(val1);
29460 {
29461 PyThreadState* __tstate = wxPyBeginAllowThreads();
29462 wxIdleEvent::SetMode(arg1);
29463 wxPyEndAllowThreads(__tstate);
29464 if (PyErr_Occurred()) SWIG_fail;
29465 }
29466 resultobj = SWIG_Py_Void();
29467 return resultobj;
29468 fail:
29469 return NULL;
29470 }
29471
29472
29473 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29474 PyObject *resultobj = 0;
29475 wxIdleMode result;
29476
29477 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
29478 {
29479 PyThreadState* __tstate = wxPyBeginAllowThreads();
29480 result = (wxIdleMode)wxIdleEvent::GetMode();
29481 wxPyEndAllowThreads(__tstate);
29482 if (PyErr_Occurred()) SWIG_fail;
29483 }
29484 resultobj = SWIG_From_int(static_cast< int >(result));
29485 return resultobj;
29486 fail:
29487 return NULL;
29488 }
29489
29490
29491 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29492 PyObject *resultobj = 0;
29493 wxWindow *arg1 = (wxWindow *) 0 ;
29494 bool result;
29495 void *argp1 = 0 ;
29496 int res1 = 0 ;
29497 PyObject * obj0 = 0 ;
29498 char * kwnames[] = {
29499 (char *) "win", NULL
29500 };
29501
29502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
29503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29504 if (!SWIG_IsOK(res1)) {
29505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
29506 }
29507 arg1 = reinterpret_cast< wxWindow * >(argp1);
29508 {
29509 PyThreadState* __tstate = wxPyBeginAllowThreads();
29510 result = (bool)wxIdleEvent::CanSend(arg1);
29511 wxPyEndAllowThreads(__tstate);
29512 if (PyErr_Occurred()) SWIG_fail;
29513 }
29514 {
29515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29516 }
29517 return resultobj;
29518 fail:
29519 return NULL;
29520 }
29521
29522
29523 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29524 PyObject *obj;
29525 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29526 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
29527 return SWIG_Py_Void();
29528 }
29529
29530 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29531 return SWIG_Python_InitShadowInstance(args);
29532 }
29533
29534 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29535 PyObject *resultobj = 0;
29536 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29537 int arg2 = (int) 0 ;
29538 wxClipboardTextEvent *result = 0 ;
29539 int val1 ;
29540 int ecode1 = 0 ;
29541 int val2 ;
29542 int ecode2 = 0 ;
29543 PyObject * obj0 = 0 ;
29544 PyObject * obj1 = 0 ;
29545 char * kwnames[] = {
29546 (char *) "type",(char *) "winid", NULL
29547 };
29548
29549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29550 if (obj0) {
29551 ecode1 = SWIG_AsVal_int(obj0, &val1);
29552 if (!SWIG_IsOK(ecode1)) {
29553 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29554 }
29555 arg1 = static_cast< wxEventType >(val1);
29556 }
29557 if (obj1) {
29558 ecode2 = SWIG_AsVal_int(obj1, &val2);
29559 if (!SWIG_IsOK(ecode2)) {
29560 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
29561 }
29562 arg2 = static_cast< int >(val2);
29563 }
29564 {
29565 PyThreadState* __tstate = wxPyBeginAllowThreads();
29566 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
29567 wxPyEndAllowThreads(__tstate);
29568 if (PyErr_Occurred()) SWIG_fail;
29569 }
29570 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
29571 return resultobj;
29572 fail:
29573 return NULL;
29574 }
29575
29576
29577 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29578 PyObject *obj;
29579 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29580 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
29581 return SWIG_Py_Void();
29582 }
29583
29584 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29585 return SWIG_Python_InitShadowInstance(args);
29586 }
29587
29588 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29589 PyObject *resultobj = 0;
29590 int arg1 = (int) 0 ;
29591 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
29592 wxPyEvent *result = 0 ;
29593 int val1 ;
29594 int ecode1 = 0 ;
29595 int val2 ;
29596 int ecode2 = 0 ;
29597 PyObject * obj0 = 0 ;
29598 PyObject * obj1 = 0 ;
29599 char * kwnames[] = {
29600 (char *) "winid",(char *) "eventType", NULL
29601 };
29602
29603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29604 if (obj0) {
29605 ecode1 = SWIG_AsVal_int(obj0, &val1);
29606 if (!SWIG_IsOK(ecode1)) {
29607 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
29608 }
29609 arg1 = static_cast< int >(val1);
29610 }
29611 if (obj1) {
29612 ecode2 = SWIG_AsVal_int(obj1, &val2);
29613 if (!SWIG_IsOK(ecode2)) {
29614 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
29615 }
29616 arg2 = static_cast< wxEventType >(val2);
29617 }
29618 {
29619 PyThreadState* __tstate = wxPyBeginAllowThreads();
29620 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
29621 wxPyEndAllowThreads(__tstate);
29622 if (PyErr_Occurred()) SWIG_fail;
29623 }
29624 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
29625 return resultobj;
29626 fail:
29627 return NULL;
29628 }
29629
29630
29631 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29632 PyObject *resultobj = 0;
29633 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29634 void *argp1 = 0 ;
29635 int res1 = 0 ;
29636 PyObject *swig_obj[1] ;
29637
29638 if (!args) SWIG_fail;
29639 swig_obj[0] = args;
29640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
29641 if (!SWIG_IsOK(res1)) {
29642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29643 }
29644 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29645 {
29646 PyThreadState* __tstate = wxPyBeginAllowThreads();
29647 delete arg1;
29648
29649 wxPyEndAllowThreads(__tstate);
29650 if (PyErr_Occurred()) SWIG_fail;
29651 }
29652 resultobj = SWIG_Py_Void();
29653 return resultobj;
29654 fail:
29655 return NULL;
29656 }
29657
29658
29659 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29660 PyObject *resultobj = 0;
29661 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29662 PyObject *arg2 = (PyObject *) 0 ;
29663 void *argp1 = 0 ;
29664 int res1 = 0 ;
29665 PyObject * obj0 = 0 ;
29666 PyObject * obj1 = 0 ;
29667 char * kwnames[] = {
29668 (char *) "self",(char *) "self", NULL
29669 };
29670
29671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
29672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
29673 if (!SWIG_IsOK(res1)) {
29674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29675 }
29676 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29677 arg2 = obj1;
29678 {
29679 PyThreadState* __tstate = wxPyBeginAllowThreads();
29680 (arg1)->SetSelf(arg2);
29681 wxPyEndAllowThreads(__tstate);
29682 if (PyErr_Occurred()) SWIG_fail;
29683 }
29684 resultobj = SWIG_Py_Void();
29685 return resultobj;
29686 fail:
29687 return NULL;
29688 }
29689
29690
29691 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29692 PyObject *resultobj = 0;
29693 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29694 PyObject *result = 0 ;
29695 void *argp1 = 0 ;
29696 int res1 = 0 ;
29697 PyObject *swig_obj[1] ;
29698
29699 if (!args) SWIG_fail;
29700 swig_obj[0] = args;
29701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
29702 if (!SWIG_IsOK(res1)) {
29703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29704 }
29705 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29706 {
29707 PyThreadState* __tstate = wxPyBeginAllowThreads();
29708 result = (PyObject *)(arg1)->GetSelf();
29709 wxPyEndAllowThreads(__tstate);
29710 if (PyErr_Occurred()) SWIG_fail;
29711 }
29712 resultobj = result;
29713 return resultobj;
29714 fail:
29715 return NULL;
29716 }
29717
29718
29719 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29720 PyObject *obj;
29721 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29722 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
29723 return SWIG_Py_Void();
29724 }
29725
29726 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29727 return SWIG_Python_InitShadowInstance(args);
29728 }
29729
29730 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29731 PyObject *resultobj = 0;
29732 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29733 int arg2 = (int) 0 ;
29734 wxPyCommandEvent *result = 0 ;
29735 int val1 ;
29736 int ecode1 = 0 ;
29737 int val2 ;
29738 int ecode2 = 0 ;
29739 PyObject * obj0 = 0 ;
29740 PyObject * obj1 = 0 ;
29741 char * kwnames[] = {
29742 (char *) "eventType",(char *) "id", NULL
29743 };
29744
29745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29746 if (obj0) {
29747 ecode1 = SWIG_AsVal_int(obj0, &val1);
29748 if (!SWIG_IsOK(ecode1)) {
29749 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29750 }
29751 arg1 = static_cast< wxEventType >(val1);
29752 }
29753 if (obj1) {
29754 ecode2 = SWIG_AsVal_int(obj1, &val2);
29755 if (!SWIG_IsOK(ecode2)) {
29756 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
29757 }
29758 arg2 = static_cast< int >(val2);
29759 }
29760 {
29761 PyThreadState* __tstate = wxPyBeginAllowThreads();
29762 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
29763 wxPyEndAllowThreads(__tstate);
29764 if (PyErr_Occurred()) SWIG_fail;
29765 }
29766 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
29767 return resultobj;
29768 fail:
29769 return NULL;
29770 }
29771
29772
29773 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29774 PyObject *resultobj = 0;
29775 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29776 void *argp1 = 0 ;
29777 int res1 = 0 ;
29778 PyObject *swig_obj[1] ;
29779
29780 if (!args) SWIG_fail;
29781 swig_obj[0] = args;
29782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
29783 if (!SWIG_IsOK(res1)) {
29784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29785 }
29786 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29787 {
29788 PyThreadState* __tstate = wxPyBeginAllowThreads();
29789 delete arg1;
29790
29791 wxPyEndAllowThreads(__tstate);
29792 if (PyErr_Occurred()) SWIG_fail;
29793 }
29794 resultobj = SWIG_Py_Void();
29795 return resultobj;
29796 fail:
29797 return NULL;
29798 }
29799
29800
29801 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29802 PyObject *resultobj = 0;
29803 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29804 PyObject *arg2 = (PyObject *) 0 ;
29805 void *argp1 = 0 ;
29806 int res1 = 0 ;
29807 PyObject * obj0 = 0 ;
29808 PyObject * obj1 = 0 ;
29809 char * kwnames[] = {
29810 (char *) "self",(char *) "self", NULL
29811 };
29812
29813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
29814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
29815 if (!SWIG_IsOK(res1)) {
29816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29817 }
29818 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29819 arg2 = obj1;
29820 {
29821 PyThreadState* __tstate = wxPyBeginAllowThreads();
29822 (arg1)->SetSelf(arg2);
29823 wxPyEndAllowThreads(__tstate);
29824 if (PyErr_Occurred()) SWIG_fail;
29825 }
29826 resultobj = SWIG_Py_Void();
29827 return resultobj;
29828 fail:
29829 return NULL;
29830 }
29831
29832
29833 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29834 PyObject *resultobj = 0;
29835 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29836 PyObject *result = 0 ;
29837 void *argp1 = 0 ;
29838 int res1 = 0 ;
29839 PyObject *swig_obj[1] ;
29840
29841 if (!args) SWIG_fail;
29842 swig_obj[0] = args;
29843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
29844 if (!SWIG_IsOK(res1)) {
29845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29846 }
29847 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29848 {
29849 PyThreadState* __tstate = wxPyBeginAllowThreads();
29850 result = (PyObject *)(arg1)->GetSelf();
29851 wxPyEndAllowThreads(__tstate);
29852 if (PyErr_Occurred()) SWIG_fail;
29853 }
29854 resultobj = result;
29855 return resultobj;
29856 fail:
29857 return NULL;
29858 }
29859
29860
29861 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29862 PyObject *obj;
29863 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29864 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
29865 return SWIG_Py_Void();
29866 }
29867
29868 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29869 return SWIG_Python_InitShadowInstance(args);
29870 }
29871
29872 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29873 PyObject *resultobj = 0;
29874 wxWindow *arg1 = (wxWindow *) 0 ;
29875 wxDateTime *arg2 = 0 ;
29876 wxEventType arg3 ;
29877 wxDateEvent *result = 0 ;
29878 void *argp1 = 0 ;
29879 int res1 = 0 ;
29880 void *argp2 = 0 ;
29881 int res2 = 0 ;
29882 int val3 ;
29883 int ecode3 = 0 ;
29884 PyObject * obj0 = 0 ;
29885 PyObject * obj1 = 0 ;
29886 PyObject * obj2 = 0 ;
29887 char * kwnames[] = {
29888 (char *) "win",(char *) "dt",(char *) "type", NULL
29889 };
29890
29891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29893 if (!SWIG_IsOK(res1)) {
29894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29895 }
29896 arg1 = reinterpret_cast< wxWindow * >(argp1);
29897 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
29898 if (!SWIG_IsOK(res2)) {
29899 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29900 }
29901 if (!argp2) {
29902 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29903 }
29904 arg2 = reinterpret_cast< wxDateTime * >(argp2);
29905 ecode3 = SWIG_AsVal_int(obj2, &val3);
29906 if (!SWIG_IsOK(ecode3)) {
29907 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
29908 }
29909 arg3 = static_cast< wxEventType >(val3);
29910 {
29911 PyThreadState* __tstate = wxPyBeginAllowThreads();
29912 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
29913 wxPyEndAllowThreads(__tstate);
29914 if (PyErr_Occurred()) SWIG_fail;
29915 }
29916 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
29917 return resultobj;
29918 fail:
29919 return NULL;
29920 }
29921
29922
29923 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29924 PyObject *resultobj = 0;
29925 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
29926 wxDateTime *result = 0 ;
29927 void *argp1 = 0 ;
29928 int res1 = 0 ;
29929 PyObject *swig_obj[1] ;
29930
29931 if (!args) SWIG_fail;
29932 swig_obj[0] = args;
29933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
29934 if (!SWIG_IsOK(res1)) {
29935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
29936 }
29937 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
29938 {
29939 PyThreadState* __tstate = wxPyBeginAllowThreads();
29940 {
29941 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
29942 result = (wxDateTime *) &_result_ref;
29943 }
29944 wxPyEndAllowThreads(__tstate);
29945 if (PyErr_Occurred()) SWIG_fail;
29946 }
29947 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
29948 return resultobj;
29949 fail:
29950 return NULL;
29951 }
29952
29953
29954 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29955 PyObject *resultobj = 0;
29956 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
29957 wxDateTime *arg2 = 0 ;
29958 void *argp1 = 0 ;
29959 int res1 = 0 ;
29960 void *argp2 = 0 ;
29961 int res2 = 0 ;
29962 PyObject * obj0 = 0 ;
29963 PyObject * obj1 = 0 ;
29964 char * kwnames[] = {
29965 (char *) "self",(char *) "date", NULL
29966 };
29967
29968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
29969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
29970 if (!SWIG_IsOK(res1)) {
29971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
29972 }
29973 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
29974 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
29975 if (!SWIG_IsOK(res2)) {
29976 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29977 }
29978 if (!argp2) {
29979 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29980 }
29981 arg2 = reinterpret_cast< wxDateTime * >(argp2);
29982 {
29983 PyThreadState* __tstate = wxPyBeginAllowThreads();
29984 (arg1)->SetDate((wxDateTime const &)*arg2);
29985 wxPyEndAllowThreads(__tstate);
29986 if (PyErr_Occurred()) SWIG_fail;
29987 }
29988 resultobj = SWIG_Py_Void();
29989 return resultobj;
29990 fail:
29991 return NULL;
29992 }
29993
29994
29995 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29996 PyObject *obj;
29997 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29998 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
29999 return SWIG_Py_Void();
30000 }
30001
30002 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30003 return SWIG_Python_InitShadowInstance(args);
30004 }
30005
30006 SWIGINTERN PyObject *_wrap_new_EventBlocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30007 PyObject *resultobj = 0;
30008 wxWindow *arg1 = (wxWindow *) 0 ;
30009 wxEventType arg2 = (wxEventType) wxEVT_ANY ;
30010 wxEventBlocker *result = 0 ;
30011 void *argp1 = 0 ;
30012 int res1 = 0 ;
30013 int val2 ;
30014 int ecode2 = 0 ;
30015 PyObject * obj0 = 0 ;
30016 PyObject * obj1 = 0 ;
30017 char * kwnames[] = {
30018 (char *) "win",(char *) "type", NULL
30019 };
30020
30021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_EventBlocker",kwnames,&obj0,&obj1)) SWIG_fail;
30022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30023 if (!SWIG_IsOK(res1)) {
30024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventBlocker" "', expected argument " "1"" of type '" "wxWindow *""'");
30025 }
30026 arg1 = reinterpret_cast< wxWindow * >(argp1);
30027 if (obj1) {
30028 ecode2 = SWIG_AsVal_int(obj1, &val2);
30029 if (!SWIG_IsOK(ecode2)) {
30030 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EventBlocker" "', expected argument " "2"" of type '" "wxEventType""'");
30031 }
30032 arg2 = static_cast< wxEventType >(val2);
30033 }
30034 {
30035 PyThreadState* __tstate = wxPyBeginAllowThreads();
30036 result = (wxEventBlocker *)new wxEventBlocker(arg1,arg2);
30037 wxPyEndAllowThreads(__tstate);
30038 if (PyErr_Occurred()) SWIG_fail;
30039 }
30040 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventBlocker, SWIG_POINTER_NEW | 0 );
30041 return resultobj;
30042 fail:
30043 return NULL;
30044 }
30045
30046
30047 SWIGINTERN PyObject *_wrap_delete_EventBlocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30048 PyObject *resultobj = 0;
30049 wxEventBlocker *arg1 = (wxEventBlocker *) 0 ;
30050 void *argp1 = 0 ;
30051 int res1 = 0 ;
30052 PyObject *swig_obj[1] ;
30053
30054 if (!args) SWIG_fail;
30055 swig_obj[0] = args;
30056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventBlocker, SWIG_POINTER_DISOWN | 0 );
30057 if (!SWIG_IsOK(res1)) {
30058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventBlocker" "', expected argument " "1"" of type '" "wxEventBlocker *""'");
30059 }
30060 arg1 = reinterpret_cast< wxEventBlocker * >(argp1);
30061 {
30062 PyThreadState* __tstate = wxPyBeginAllowThreads();
30063 delete arg1;
30064
30065 wxPyEndAllowThreads(__tstate);
30066 if (PyErr_Occurred()) SWIG_fail;
30067 }
30068 resultobj = SWIG_Py_Void();
30069 return resultobj;
30070 fail:
30071 return NULL;
30072 }
30073
30074
30075 SWIGINTERN PyObject *_wrap_EventBlocker_Block(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30076 PyObject *resultobj = 0;
30077 wxEventBlocker *arg1 = (wxEventBlocker *) 0 ;
30078 wxEventType arg2 ;
30079 void *argp1 = 0 ;
30080 int res1 = 0 ;
30081 int val2 ;
30082 int ecode2 = 0 ;
30083 PyObject * obj0 = 0 ;
30084 PyObject * obj1 = 0 ;
30085 char * kwnames[] = {
30086 (char *) "self",(char *) "type", NULL
30087 };
30088
30089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EventBlocker_Block",kwnames,&obj0,&obj1)) SWIG_fail;
30090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventBlocker, 0 | 0 );
30091 if (!SWIG_IsOK(res1)) {
30092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventBlocker_Block" "', expected argument " "1"" of type '" "wxEventBlocker *""'");
30093 }
30094 arg1 = reinterpret_cast< wxEventBlocker * >(argp1);
30095 ecode2 = SWIG_AsVal_int(obj1, &val2);
30096 if (!SWIG_IsOK(ecode2)) {
30097 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventBlocker_Block" "', expected argument " "2"" of type '" "wxEventType""'");
30098 }
30099 arg2 = static_cast< wxEventType >(val2);
30100 {
30101 PyThreadState* __tstate = wxPyBeginAllowThreads();
30102 (arg1)->Block(arg2);
30103 wxPyEndAllowThreads(__tstate);
30104 if (PyErr_Occurred()) SWIG_fail;
30105 }
30106 resultobj = SWIG_Py_Void();
30107 return resultobj;
30108 fail:
30109 return NULL;
30110 }
30111
30112
30113 SWIGINTERN PyObject *EventBlocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30114 PyObject *obj;
30115 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30116 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventBlocker, SWIG_NewClientData(obj));
30117 return SWIG_Py_Void();
30118 }
30119
30120 SWIGINTERN PyObject *EventBlocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30121 return SWIG_Python_InitShadowInstance(args);
30122 }
30123
30124 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30125 PyObject *resultobj = 0;
30126 wxPyApp *result = 0 ;
30127
30128 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
30129 {
30130 PyThreadState* __tstate = wxPyBeginAllowThreads();
30131 result = (wxPyApp *)new_wxPyApp();
30132 wxPyEndAllowThreads(__tstate);
30133 if (PyErr_Occurred()) SWIG_fail;
30134 }
30135 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
30136 return resultobj;
30137 fail:
30138 return NULL;
30139 }
30140
30141
30142 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30143 PyObject *resultobj = 0;
30144 wxPyApp *arg1 = (wxPyApp *) 0 ;
30145 void *argp1 = 0 ;
30146 int res1 = 0 ;
30147 PyObject *swig_obj[1] ;
30148
30149 if (!args) SWIG_fail;
30150 swig_obj[0] = args;
30151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
30152 if (!SWIG_IsOK(res1)) {
30153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
30154 }
30155 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30156 {
30157 PyThreadState* __tstate = wxPyBeginAllowThreads();
30158 delete arg1;
30159
30160 wxPyEndAllowThreads(__tstate);
30161 if (PyErr_Occurred()) SWIG_fail;
30162 }
30163 resultobj = SWIG_Py_Void();
30164 return resultobj;
30165 fail:
30166 return NULL;
30167 }
30168
30169
30170 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30171 PyObject *resultobj = 0;
30172 wxPyApp *arg1 = (wxPyApp *) 0 ;
30173 PyObject *arg2 = (PyObject *) 0 ;
30174 PyObject *arg3 = (PyObject *) 0 ;
30175 bool arg4 = (bool) false ;
30176 void *argp1 = 0 ;
30177 int res1 = 0 ;
30178 bool val4 ;
30179 int ecode4 = 0 ;
30180 PyObject * obj0 = 0 ;
30181 PyObject * obj1 = 0 ;
30182 PyObject * obj2 = 0 ;
30183 PyObject * obj3 = 0 ;
30184 char * kwnames[] = {
30185 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
30186 };
30187
30188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30190 if (!SWIG_IsOK(res1)) {
30191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
30192 }
30193 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30194 arg2 = obj1;
30195 arg3 = obj2;
30196 if (obj3) {
30197 ecode4 = SWIG_AsVal_bool(obj3, &val4);
30198 if (!SWIG_IsOK(ecode4)) {
30199 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
30200 }
30201 arg4 = static_cast< bool >(val4);
30202 }
30203 {
30204 PyThreadState* __tstate = wxPyBeginAllowThreads();
30205 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
30206 wxPyEndAllowThreads(__tstate);
30207 if (PyErr_Occurred()) SWIG_fail;
30208 }
30209 resultobj = SWIG_Py_Void();
30210 return resultobj;
30211 fail:
30212 return NULL;
30213 }
30214
30215
30216 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30217 PyObject *resultobj = 0;
30218 wxPyApp *arg1 = (wxPyApp *) 0 ;
30219 wxString result;
30220 void *argp1 = 0 ;
30221 int res1 = 0 ;
30222 PyObject *swig_obj[1] ;
30223
30224 if (!args) SWIG_fail;
30225 swig_obj[0] = args;
30226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30227 if (!SWIG_IsOK(res1)) {
30228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30229 }
30230 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30231 {
30232 PyThreadState* __tstate = wxPyBeginAllowThreads();
30233 result = ((wxPyApp const *)arg1)->GetAppName();
30234 wxPyEndAllowThreads(__tstate);
30235 if (PyErr_Occurred()) SWIG_fail;
30236 }
30237 {
30238 #if wxUSE_UNICODE
30239 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30240 #else
30241 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30242 #endif
30243 }
30244 return resultobj;
30245 fail:
30246 return NULL;
30247 }
30248
30249
30250 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30251 PyObject *resultobj = 0;
30252 wxPyApp *arg1 = (wxPyApp *) 0 ;
30253 wxString *arg2 = 0 ;
30254 void *argp1 = 0 ;
30255 int res1 = 0 ;
30256 bool temp2 = false ;
30257 PyObject * obj0 = 0 ;
30258 PyObject * obj1 = 0 ;
30259 char * kwnames[] = {
30260 (char *) "self",(char *) "name", NULL
30261 };
30262
30263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
30264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30265 if (!SWIG_IsOK(res1)) {
30266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30267 }
30268 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30269 {
30270 arg2 = wxString_in_helper(obj1);
30271 if (arg2 == NULL) SWIG_fail;
30272 temp2 = true;
30273 }
30274 {
30275 PyThreadState* __tstate = wxPyBeginAllowThreads();
30276 (arg1)->SetAppName((wxString const &)*arg2);
30277 wxPyEndAllowThreads(__tstate);
30278 if (PyErr_Occurred()) SWIG_fail;
30279 }
30280 resultobj = SWIG_Py_Void();
30281 {
30282 if (temp2)
30283 delete arg2;
30284 }
30285 return resultobj;
30286 fail:
30287 {
30288 if (temp2)
30289 delete arg2;
30290 }
30291 return NULL;
30292 }
30293
30294
30295 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30296 PyObject *resultobj = 0;
30297 wxPyApp *arg1 = (wxPyApp *) 0 ;
30298 wxString result;
30299 void *argp1 = 0 ;
30300 int res1 = 0 ;
30301 PyObject *swig_obj[1] ;
30302
30303 if (!args) SWIG_fail;
30304 swig_obj[0] = args;
30305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30306 if (!SWIG_IsOK(res1)) {
30307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30308 }
30309 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30310 {
30311 PyThreadState* __tstate = wxPyBeginAllowThreads();
30312 result = ((wxPyApp const *)arg1)->GetClassName();
30313 wxPyEndAllowThreads(__tstate);
30314 if (PyErr_Occurred()) SWIG_fail;
30315 }
30316 {
30317 #if wxUSE_UNICODE
30318 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30319 #else
30320 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30321 #endif
30322 }
30323 return resultobj;
30324 fail:
30325 return NULL;
30326 }
30327
30328
30329 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30330 PyObject *resultobj = 0;
30331 wxPyApp *arg1 = (wxPyApp *) 0 ;
30332 wxString *arg2 = 0 ;
30333 void *argp1 = 0 ;
30334 int res1 = 0 ;
30335 bool temp2 = false ;
30336 PyObject * obj0 = 0 ;
30337 PyObject * obj1 = 0 ;
30338 char * kwnames[] = {
30339 (char *) "self",(char *) "name", NULL
30340 };
30341
30342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
30343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30344 if (!SWIG_IsOK(res1)) {
30345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30346 }
30347 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30348 {
30349 arg2 = wxString_in_helper(obj1);
30350 if (arg2 == NULL) SWIG_fail;
30351 temp2 = true;
30352 }
30353 {
30354 PyThreadState* __tstate = wxPyBeginAllowThreads();
30355 (arg1)->SetClassName((wxString const &)*arg2);
30356 wxPyEndAllowThreads(__tstate);
30357 if (PyErr_Occurred()) SWIG_fail;
30358 }
30359 resultobj = SWIG_Py_Void();
30360 {
30361 if (temp2)
30362 delete arg2;
30363 }
30364 return resultobj;
30365 fail:
30366 {
30367 if (temp2)
30368 delete arg2;
30369 }
30370 return NULL;
30371 }
30372
30373
30374 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30375 PyObject *resultobj = 0;
30376 wxPyApp *arg1 = (wxPyApp *) 0 ;
30377 wxString *result = 0 ;
30378 void *argp1 = 0 ;
30379 int res1 = 0 ;
30380 PyObject *swig_obj[1] ;
30381
30382 if (!args) SWIG_fail;
30383 swig_obj[0] = args;
30384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30385 if (!SWIG_IsOK(res1)) {
30386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30387 }
30388 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30389 {
30390 PyThreadState* __tstate = wxPyBeginAllowThreads();
30391 {
30392 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
30393 result = (wxString *) &_result_ref;
30394 }
30395 wxPyEndAllowThreads(__tstate);
30396 if (PyErr_Occurred()) SWIG_fail;
30397 }
30398 {
30399 #if wxUSE_UNICODE
30400 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
30401 #else
30402 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
30403 #endif
30404 }
30405 return resultobj;
30406 fail:
30407 return NULL;
30408 }
30409
30410
30411 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30412 PyObject *resultobj = 0;
30413 wxPyApp *arg1 = (wxPyApp *) 0 ;
30414 wxString *arg2 = 0 ;
30415 void *argp1 = 0 ;
30416 int res1 = 0 ;
30417 bool temp2 = false ;
30418 PyObject * obj0 = 0 ;
30419 PyObject * obj1 = 0 ;
30420 char * kwnames[] = {
30421 (char *) "self",(char *) "name", NULL
30422 };
30423
30424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
30425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30426 if (!SWIG_IsOK(res1)) {
30427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30428 }
30429 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30430 {
30431 arg2 = wxString_in_helper(obj1);
30432 if (arg2 == NULL) SWIG_fail;
30433 temp2 = true;
30434 }
30435 {
30436 PyThreadState* __tstate = wxPyBeginAllowThreads();
30437 (arg1)->SetVendorName((wxString const &)*arg2);
30438 wxPyEndAllowThreads(__tstate);
30439 if (PyErr_Occurred()) SWIG_fail;
30440 }
30441 resultobj = SWIG_Py_Void();
30442 {
30443 if (temp2)
30444 delete arg2;
30445 }
30446 return resultobj;
30447 fail:
30448 {
30449 if (temp2)
30450 delete arg2;
30451 }
30452 return NULL;
30453 }
30454
30455
30456 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30457 PyObject *resultobj = 0;
30458 wxPyApp *arg1 = (wxPyApp *) 0 ;
30459 wxAppTraits *result = 0 ;
30460 void *argp1 = 0 ;
30461 int res1 = 0 ;
30462 PyObject *swig_obj[1] ;
30463
30464 if (!args) SWIG_fail;
30465 swig_obj[0] = args;
30466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30467 if (!SWIG_IsOK(res1)) {
30468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
30469 }
30470 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30471 {
30472 PyThreadState* __tstate = wxPyBeginAllowThreads();
30473 result = (wxAppTraits *)(arg1)->GetTraits();
30474 wxPyEndAllowThreads(__tstate);
30475 if (PyErr_Occurred()) SWIG_fail;
30476 }
30477 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
30478 return resultobj;
30479 fail:
30480 return NULL;
30481 }
30482
30483
30484 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30485 PyObject *resultobj = 0;
30486 wxPyApp *arg1 = (wxPyApp *) 0 ;
30487 void *argp1 = 0 ;
30488 int res1 = 0 ;
30489 PyObject *swig_obj[1] ;
30490
30491 if (!args) SWIG_fail;
30492 swig_obj[0] = args;
30493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30494 if (!SWIG_IsOK(res1)) {
30495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
30496 }
30497 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30498 {
30499 PyThreadState* __tstate = wxPyBeginAllowThreads();
30500 (arg1)->ProcessPendingEvents();
30501 wxPyEndAllowThreads(__tstate);
30502 if (PyErr_Occurred()) SWIG_fail;
30503 }
30504 resultobj = SWIG_Py_Void();
30505 return resultobj;
30506 fail:
30507 return NULL;
30508 }
30509
30510
30511 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30512 PyObject *resultobj = 0;
30513 wxPyApp *arg1 = (wxPyApp *) 0 ;
30514 bool arg2 = (bool) false ;
30515 bool result;
30516 void *argp1 = 0 ;
30517 int res1 = 0 ;
30518 bool val2 ;
30519 int ecode2 = 0 ;
30520 PyObject * obj0 = 0 ;
30521 PyObject * obj1 = 0 ;
30522 char * kwnames[] = {
30523 (char *) "self",(char *) "onlyIfNeeded", NULL
30524 };
30525
30526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
30527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30528 if (!SWIG_IsOK(res1)) {
30529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
30530 }
30531 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30532 if (obj1) {
30533 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30534 if (!SWIG_IsOK(ecode2)) {
30535 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
30536 }
30537 arg2 = static_cast< bool >(val2);
30538 }
30539 {
30540 PyThreadState* __tstate = wxPyBeginAllowThreads();
30541 result = (bool)(arg1)->Yield(arg2);
30542 wxPyEndAllowThreads(__tstate);
30543 if (PyErr_Occurred()) SWIG_fail;
30544 }
30545 {
30546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30547 }
30548 return resultobj;
30549 fail:
30550 return NULL;
30551 }
30552
30553
30554 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30555 PyObject *resultobj = 0;
30556 wxPyApp *arg1 = (wxPyApp *) 0 ;
30557 void *argp1 = 0 ;
30558 int res1 = 0 ;
30559 PyObject *swig_obj[1] ;
30560
30561 if (!args) SWIG_fail;
30562 swig_obj[0] = args;
30563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30564 if (!SWIG_IsOK(res1)) {
30565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
30566 }
30567 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30568 {
30569 PyThreadState* __tstate = wxPyBeginAllowThreads();
30570 (arg1)->WakeUpIdle();
30571 wxPyEndAllowThreads(__tstate);
30572 if (PyErr_Occurred()) SWIG_fail;
30573 }
30574 resultobj = SWIG_Py_Void();
30575 return resultobj;
30576 fail:
30577 return NULL;
30578 }
30579
30580
30581 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30582 PyObject *resultobj = 0;
30583 bool result;
30584
30585 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
30586 {
30587 PyThreadState* __tstate = wxPyBeginAllowThreads();
30588 result = (bool)wxPyApp::IsMainLoopRunning();
30589 wxPyEndAllowThreads(__tstate);
30590 if (PyErr_Occurred()) SWIG_fail;
30591 }
30592 {
30593 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30594 }
30595 return resultobj;
30596 fail:
30597 return NULL;
30598 }
30599
30600
30601 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30602 PyObject *resultobj = 0;
30603 wxPyApp *arg1 = (wxPyApp *) 0 ;
30604 int result;
30605 void *argp1 = 0 ;
30606 int res1 = 0 ;
30607 PyObject *swig_obj[1] ;
30608
30609 if (!args) SWIG_fail;
30610 swig_obj[0] = args;
30611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30612 if (!SWIG_IsOK(res1)) {
30613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
30614 }
30615 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30616 {
30617 PyThreadState* __tstate = wxPyBeginAllowThreads();
30618 result = (int)(arg1)->MainLoop();
30619 wxPyEndAllowThreads(__tstate);
30620 if (PyErr_Occurred()) SWIG_fail;
30621 }
30622 resultobj = SWIG_From_int(static_cast< int >(result));
30623 return resultobj;
30624 fail:
30625 return NULL;
30626 }
30627
30628
30629 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30630 PyObject *resultobj = 0;
30631 wxPyApp *arg1 = (wxPyApp *) 0 ;
30632 void *argp1 = 0 ;
30633 int res1 = 0 ;
30634 PyObject *swig_obj[1] ;
30635
30636 if (!args) SWIG_fail;
30637 swig_obj[0] = args;
30638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30639 if (!SWIG_IsOK(res1)) {
30640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
30641 }
30642 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30643 {
30644 PyThreadState* __tstate = wxPyBeginAllowThreads();
30645 (arg1)->Exit();
30646 wxPyEndAllowThreads(__tstate);
30647 if (PyErr_Occurred()) SWIG_fail;
30648 }
30649 resultobj = SWIG_Py_Void();
30650 return resultobj;
30651 fail:
30652 return NULL;
30653 }
30654
30655
30656 SWIGINTERN PyObject *_wrap_PyApp_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30657 PyObject *resultobj = 0;
30658 wxPyApp *arg1 = (wxPyApp *) 0 ;
30659 wxLayoutDirection result;
30660 void *argp1 = 0 ;
30661 int res1 = 0 ;
30662 PyObject *swig_obj[1] ;
30663
30664 if (!args) SWIG_fail;
30665 swig_obj[0] = args;
30666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30667 if (!SWIG_IsOK(res1)) {
30668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetLayoutDirection" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30669 }
30670 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30671 {
30672 PyThreadState* __tstate = wxPyBeginAllowThreads();
30673 result = (wxLayoutDirection)((wxPyApp const *)arg1)->GetLayoutDirection();
30674 wxPyEndAllowThreads(__tstate);
30675 if (PyErr_Occurred()) SWIG_fail;
30676 }
30677 resultobj = SWIG_From_int(static_cast< int >(result));
30678 return resultobj;
30679 fail:
30680 return NULL;
30681 }
30682
30683
30684 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30685 PyObject *resultobj = 0;
30686 wxPyApp *arg1 = (wxPyApp *) 0 ;
30687 void *argp1 = 0 ;
30688 int res1 = 0 ;
30689 PyObject *swig_obj[1] ;
30690
30691 if (!args) SWIG_fail;
30692 swig_obj[0] = args;
30693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30694 if (!SWIG_IsOK(res1)) {
30695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
30696 }
30697 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30698 {
30699 PyThreadState* __tstate = wxPyBeginAllowThreads();
30700 (arg1)->ExitMainLoop();
30701 wxPyEndAllowThreads(__tstate);
30702 if (PyErr_Occurred()) SWIG_fail;
30703 }
30704 resultobj = SWIG_Py_Void();
30705 return resultobj;
30706 fail:
30707 return NULL;
30708 }
30709
30710
30711 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30712 PyObject *resultobj = 0;
30713 wxPyApp *arg1 = (wxPyApp *) 0 ;
30714 bool result;
30715 void *argp1 = 0 ;
30716 int res1 = 0 ;
30717 PyObject *swig_obj[1] ;
30718
30719 if (!args) SWIG_fail;
30720 swig_obj[0] = args;
30721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30722 if (!SWIG_IsOK(res1)) {
30723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
30724 }
30725 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30726 {
30727 PyThreadState* __tstate = wxPyBeginAllowThreads();
30728 result = (bool)(arg1)->Pending();
30729 wxPyEndAllowThreads(__tstate);
30730 if (PyErr_Occurred()) SWIG_fail;
30731 }
30732 {
30733 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30734 }
30735 return resultobj;
30736 fail:
30737 return NULL;
30738 }
30739
30740
30741 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30742 PyObject *resultobj = 0;
30743 wxPyApp *arg1 = (wxPyApp *) 0 ;
30744 bool result;
30745 void *argp1 = 0 ;
30746 int res1 = 0 ;
30747 PyObject *swig_obj[1] ;
30748
30749 if (!args) SWIG_fail;
30750 swig_obj[0] = args;
30751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30752 if (!SWIG_IsOK(res1)) {
30753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
30754 }
30755 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30756 {
30757 PyThreadState* __tstate = wxPyBeginAllowThreads();
30758 result = (bool)(arg1)->Dispatch();
30759 wxPyEndAllowThreads(__tstate);
30760 if (PyErr_Occurred()) SWIG_fail;
30761 }
30762 {
30763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30764 }
30765 return resultobj;
30766 fail:
30767 return NULL;
30768 }
30769
30770
30771 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30772 PyObject *resultobj = 0;
30773 wxPyApp *arg1 = (wxPyApp *) 0 ;
30774 bool result;
30775 void *argp1 = 0 ;
30776 int res1 = 0 ;
30777 PyObject *swig_obj[1] ;
30778
30779 if (!args) SWIG_fail;
30780 swig_obj[0] = args;
30781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30782 if (!SWIG_IsOK(res1)) {
30783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
30784 }
30785 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30786 {
30787 PyThreadState* __tstate = wxPyBeginAllowThreads();
30788 result = (bool)(arg1)->ProcessIdle();
30789 wxPyEndAllowThreads(__tstate);
30790 if (PyErr_Occurred()) SWIG_fail;
30791 }
30792 {
30793 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30794 }
30795 return resultobj;
30796 fail:
30797 return NULL;
30798 }
30799
30800
30801 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30802 PyObject *resultobj = 0;
30803 wxPyApp *arg1 = (wxPyApp *) 0 ;
30804 wxWindow *arg2 = (wxWindow *) 0 ;
30805 wxIdleEvent *arg3 = 0 ;
30806 bool result;
30807 void *argp1 = 0 ;
30808 int res1 = 0 ;
30809 void *argp2 = 0 ;
30810 int res2 = 0 ;
30811 void *argp3 = 0 ;
30812 int res3 = 0 ;
30813 PyObject * obj0 = 0 ;
30814 PyObject * obj1 = 0 ;
30815 PyObject * obj2 = 0 ;
30816 char * kwnames[] = {
30817 (char *) "self",(char *) "win",(char *) "event", NULL
30818 };
30819
30820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30822 if (!SWIG_IsOK(res1)) {
30823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
30824 }
30825 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30826 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30827 if (!SWIG_IsOK(res2)) {
30828 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
30829 }
30830 arg2 = reinterpret_cast< wxWindow * >(argp2);
30831 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
30832 if (!SWIG_IsOK(res3)) {
30833 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
30834 }
30835 if (!argp3) {
30836 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
30837 }
30838 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
30839 {
30840 PyThreadState* __tstate = wxPyBeginAllowThreads();
30841 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
30842 wxPyEndAllowThreads(__tstate);
30843 if (PyErr_Occurred()) SWIG_fail;
30844 }
30845 {
30846 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30847 }
30848 return resultobj;
30849 fail:
30850 return NULL;
30851 }
30852
30853
30854 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30855 PyObject *resultobj = 0;
30856 wxPyApp *arg1 = (wxPyApp *) 0 ;
30857 bool result;
30858 void *argp1 = 0 ;
30859 int res1 = 0 ;
30860 PyObject *swig_obj[1] ;
30861
30862 if (!args) SWIG_fail;
30863 swig_obj[0] = args;
30864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30865 if (!SWIG_IsOK(res1)) {
30866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30867 }
30868 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30869 {
30870 PyThreadState* __tstate = wxPyBeginAllowThreads();
30871 result = (bool)((wxPyApp const *)arg1)->IsActive();
30872 wxPyEndAllowThreads(__tstate);
30873 if (PyErr_Occurred()) SWIG_fail;
30874 }
30875 {
30876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30877 }
30878 return resultobj;
30879 fail:
30880 return NULL;
30881 }
30882
30883
30884 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30885 PyObject *resultobj = 0;
30886 wxPyApp *arg1 = (wxPyApp *) 0 ;
30887 wxWindow *arg2 = (wxWindow *) 0 ;
30888 void *argp1 = 0 ;
30889 int res1 = 0 ;
30890 void *argp2 = 0 ;
30891 int res2 = 0 ;
30892 PyObject * obj0 = 0 ;
30893 PyObject * obj1 = 0 ;
30894 char * kwnames[] = {
30895 (char *) "self",(char *) "win", NULL
30896 };
30897
30898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
30899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30900 if (!SWIG_IsOK(res1)) {
30901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
30902 }
30903 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30904 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30905 if (!SWIG_IsOK(res2)) {
30906 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
30907 }
30908 arg2 = reinterpret_cast< wxWindow * >(argp2);
30909 {
30910 PyThreadState* __tstate = wxPyBeginAllowThreads();
30911 (arg1)->SetTopWindow(arg2);
30912 wxPyEndAllowThreads(__tstate);
30913 if (PyErr_Occurred()) SWIG_fail;
30914 }
30915 resultobj = SWIG_Py_Void();
30916 return resultobj;
30917 fail:
30918 return NULL;
30919 }
30920
30921
30922 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30923 PyObject *resultobj = 0;
30924 wxPyApp *arg1 = (wxPyApp *) 0 ;
30925 wxWindow *result = 0 ;
30926 void *argp1 = 0 ;
30927 int res1 = 0 ;
30928 PyObject *swig_obj[1] ;
30929
30930 if (!args) SWIG_fail;
30931 swig_obj[0] = args;
30932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30933 if (!SWIG_IsOK(res1)) {
30934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30935 }
30936 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30937 {
30938 PyThreadState* __tstate = wxPyBeginAllowThreads();
30939 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
30940 wxPyEndAllowThreads(__tstate);
30941 if (PyErr_Occurred()) SWIG_fail;
30942 }
30943 {
30944 resultobj = wxPyMake_wxObject(result, (bool)0);
30945 }
30946 return resultobj;
30947 fail:
30948 return NULL;
30949 }
30950
30951
30952 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30953 PyObject *resultobj = 0;
30954 wxPyApp *arg1 = (wxPyApp *) 0 ;
30955 bool arg2 ;
30956 void *argp1 = 0 ;
30957 int res1 = 0 ;
30958 bool val2 ;
30959 int ecode2 = 0 ;
30960 PyObject * obj0 = 0 ;
30961 PyObject * obj1 = 0 ;
30962 char * kwnames[] = {
30963 (char *) "self",(char *) "flag", NULL
30964 };
30965
30966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) 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_SetExitOnFrameDelete" "', 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_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
30975 }
30976 arg2 = static_cast< bool >(val2);
30977 {
30978 PyThreadState* __tstate = wxPyBeginAllowThreads();
30979 (arg1)->SetExitOnFrameDelete(arg2);
30980 wxPyEndAllowThreads(__tstate);
30981 if (PyErr_Occurred()) SWIG_fail;
30982 }
30983 resultobj = SWIG_Py_Void();
30984 return resultobj;
30985 fail:
30986 return NULL;
30987 }
30988
30989
30990 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30991 PyObject *resultobj = 0;
30992 wxPyApp *arg1 = (wxPyApp *) 0 ;
30993 bool result;
30994 void *argp1 = 0 ;
30995 int res1 = 0 ;
30996 PyObject *swig_obj[1] ;
30997
30998 if (!args) SWIG_fail;
30999 swig_obj[0] = args;
31000 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31001 if (!SWIG_IsOK(res1)) {
31002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
31003 }
31004 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31005 {
31006 PyThreadState* __tstate = wxPyBeginAllowThreads();
31007 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
31008 wxPyEndAllowThreads(__tstate);
31009 if (PyErr_Occurred()) SWIG_fail;
31010 }
31011 {
31012 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31013 }
31014 return resultobj;
31015 fail:
31016 return NULL;
31017 }
31018
31019
31020 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31021 PyObject *resultobj = 0;
31022 wxPyApp *arg1 = (wxPyApp *) 0 ;
31023 bool arg2 ;
31024 bool arg3 = (bool) false ;
31025 void *argp1 = 0 ;
31026 int res1 = 0 ;
31027 bool val2 ;
31028 int ecode2 = 0 ;
31029 bool val3 ;
31030 int ecode3 = 0 ;
31031 PyObject * obj0 = 0 ;
31032 PyObject * obj1 = 0 ;
31033 PyObject * obj2 = 0 ;
31034 char * kwnames[] = {
31035 (char *) "self",(char *) "flag",(char *) "forceTrueColour", NULL
31036 };
31037
31038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31040 if (!SWIG_IsOK(res1)) {
31041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
31042 }
31043 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31044 ecode2 = SWIG_AsVal_bool(obj1, &val2);
31045 if (!SWIG_IsOK(ecode2)) {
31046 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
31047 }
31048 arg2 = static_cast< bool >(val2);
31049 if (obj2) {
31050 ecode3 = SWIG_AsVal_bool(obj2, &val3);
31051 if (!SWIG_IsOK(ecode3)) {
31052 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "3"" of type '" "bool""'");
31053 }
31054 arg3 = static_cast< bool >(val3);
31055 }
31056 {
31057 PyThreadState* __tstate = wxPyBeginAllowThreads();
31058 (arg1)->SetUseBestVisual(arg2,arg3);
31059 wxPyEndAllowThreads(__tstate);
31060 if (PyErr_Occurred()) SWIG_fail;
31061 }
31062 resultobj = SWIG_Py_Void();
31063 return resultobj;
31064 fail:
31065 return NULL;
31066 }
31067
31068
31069 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31070 PyObject *resultobj = 0;
31071 wxPyApp *arg1 = (wxPyApp *) 0 ;
31072 bool result;
31073 void *argp1 = 0 ;
31074 int res1 = 0 ;
31075 PyObject *swig_obj[1] ;
31076
31077 if (!args) SWIG_fail;
31078 swig_obj[0] = args;
31079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31080 if (!SWIG_IsOK(res1)) {
31081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
31082 }
31083 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31084 {
31085 PyThreadState* __tstate = wxPyBeginAllowThreads();
31086 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
31087 wxPyEndAllowThreads(__tstate);
31088 if (PyErr_Occurred()) SWIG_fail;
31089 }
31090 {
31091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31092 }
31093 return resultobj;
31094 fail:
31095 return NULL;
31096 }
31097
31098
31099 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31100 PyObject *resultobj = 0;
31101 wxPyApp *arg1 = (wxPyApp *) 0 ;
31102 int arg2 ;
31103 void *argp1 = 0 ;
31104 int res1 = 0 ;
31105 int val2 ;
31106 int ecode2 = 0 ;
31107 PyObject * obj0 = 0 ;
31108 PyObject * obj1 = 0 ;
31109 char * kwnames[] = {
31110 (char *) "self",(char *) "mode", NULL
31111 };
31112
31113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
31114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31115 if (!SWIG_IsOK(res1)) {
31116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
31117 }
31118 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31119 ecode2 = SWIG_AsVal_int(obj1, &val2);
31120 if (!SWIG_IsOK(ecode2)) {
31121 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
31122 }
31123 arg2 = static_cast< int >(val2);
31124 {
31125 PyThreadState* __tstate = wxPyBeginAllowThreads();
31126 (arg1)->SetPrintMode(arg2);
31127 wxPyEndAllowThreads(__tstate);
31128 if (PyErr_Occurred()) SWIG_fail;
31129 }
31130 resultobj = SWIG_Py_Void();
31131 return resultobj;
31132 fail:
31133 return NULL;
31134 }
31135
31136
31137 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31138 PyObject *resultobj = 0;
31139 wxPyApp *arg1 = (wxPyApp *) 0 ;
31140 int result;
31141 void *argp1 = 0 ;
31142 int res1 = 0 ;
31143 PyObject *swig_obj[1] ;
31144
31145 if (!args) SWIG_fail;
31146 swig_obj[0] = args;
31147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31148 if (!SWIG_IsOK(res1)) {
31149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
31150 }
31151 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31152 {
31153 PyThreadState* __tstate = wxPyBeginAllowThreads();
31154 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
31155 wxPyEndAllowThreads(__tstate);
31156 if (PyErr_Occurred()) SWIG_fail;
31157 }
31158 resultobj = SWIG_From_int(static_cast< int >(result));
31159 return resultobj;
31160 fail:
31161 return NULL;
31162 }
31163
31164
31165 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31166 PyObject *resultobj = 0;
31167 wxPyApp *arg1 = (wxPyApp *) 0 ;
31168 int arg2 ;
31169 void *argp1 = 0 ;
31170 int res1 = 0 ;
31171 int val2 ;
31172 int ecode2 = 0 ;
31173 PyObject * obj0 = 0 ;
31174 PyObject * obj1 = 0 ;
31175 char * kwnames[] = {
31176 (char *) "self",(char *) "mode", NULL
31177 };
31178
31179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
31180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31181 if (!SWIG_IsOK(res1)) {
31182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
31183 }
31184 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31185 ecode2 = SWIG_AsVal_int(obj1, &val2);
31186 if (!SWIG_IsOK(ecode2)) {
31187 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
31188 }
31189 arg2 = static_cast< int >(val2);
31190 {
31191 PyThreadState* __tstate = wxPyBeginAllowThreads();
31192 (arg1)->SetAssertMode(arg2);
31193 wxPyEndAllowThreads(__tstate);
31194 if (PyErr_Occurred()) SWIG_fail;
31195 }
31196 resultobj = SWIG_Py_Void();
31197 return resultobj;
31198 fail:
31199 return NULL;
31200 }
31201
31202
31203 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31204 PyObject *resultobj = 0;
31205 wxPyApp *arg1 = (wxPyApp *) 0 ;
31206 int result;
31207 void *argp1 = 0 ;
31208 int res1 = 0 ;
31209 PyObject *swig_obj[1] ;
31210
31211 if (!args) SWIG_fail;
31212 swig_obj[0] = args;
31213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31214 if (!SWIG_IsOK(res1)) {
31215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
31216 }
31217 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31218 {
31219 PyThreadState* __tstate = wxPyBeginAllowThreads();
31220 result = (int)(arg1)->GetAssertMode();
31221 wxPyEndAllowThreads(__tstate);
31222 if (PyErr_Occurred()) SWIG_fail;
31223 }
31224 resultobj = SWIG_From_int(static_cast< int >(result));
31225 return resultobj;
31226 fail:
31227 return NULL;
31228 }
31229
31230
31231 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31232 PyObject *resultobj = 0;
31233 bool result;
31234
31235 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
31236 {
31237 PyThreadState* __tstate = wxPyBeginAllowThreads();
31238 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
31239 wxPyEndAllowThreads(__tstate);
31240 if (PyErr_Occurred()) SWIG_fail;
31241 }
31242 {
31243 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31244 }
31245 return resultobj;
31246 fail:
31247 return NULL;
31248 }
31249
31250
31251 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31252 PyObject *resultobj = 0;
31253 long result;
31254
31255 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
31256 {
31257 PyThreadState* __tstate = wxPyBeginAllowThreads();
31258 result = (long)wxPyApp::GetMacAboutMenuItemId();
31259 wxPyEndAllowThreads(__tstate);
31260 if (PyErr_Occurred()) SWIG_fail;
31261 }
31262 resultobj = SWIG_From_long(static_cast< long >(result));
31263 return resultobj;
31264 fail:
31265 return NULL;
31266 }
31267
31268
31269 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31270 PyObject *resultobj = 0;
31271 long result;
31272
31273 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
31274 {
31275 PyThreadState* __tstate = wxPyBeginAllowThreads();
31276 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
31277 wxPyEndAllowThreads(__tstate);
31278 if (PyErr_Occurred()) SWIG_fail;
31279 }
31280 resultobj = SWIG_From_long(static_cast< long >(result));
31281 return resultobj;
31282 fail:
31283 return NULL;
31284 }
31285
31286
31287 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31288 PyObject *resultobj = 0;
31289 long result;
31290
31291 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
31292 {
31293 PyThreadState* __tstate = wxPyBeginAllowThreads();
31294 result = (long)wxPyApp::GetMacExitMenuItemId();
31295 wxPyEndAllowThreads(__tstate);
31296 if (PyErr_Occurred()) SWIG_fail;
31297 }
31298 resultobj = SWIG_From_long(static_cast< long >(result));
31299 return resultobj;
31300 fail:
31301 return NULL;
31302 }
31303
31304
31305 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31306 PyObject *resultobj = 0;
31307 wxString result;
31308
31309 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
31310 {
31311 PyThreadState* __tstate = wxPyBeginAllowThreads();
31312 result = wxPyApp::GetMacHelpMenuTitleName();
31313 wxPyEndAllowThreads(__tstate);
31314 if (PyErr_Occurred()) SWIG_fail;
31315 }
31316 {
31317 #if wxUSE_UNICODE
31318 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31319 #else
31320 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31321 #endif
31322 }
31323 return resultobj;
31324 fail:
31325 return NULL;
31326 }
31327
31328
31329 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31330 PyObject *resultobj = 0;
31331 bool arg1 ;
31332 bool val1 ;
31333 int ecode1 = 0 ;
31334 PyObject * obj0 = 0 ;
31335 char * kwnames[] = {
31336 (char *) "val", NULL
31337 };
31338
31339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
31340 ecode1 = SWIG_AsVal_bool(obj0, &val1);
31341 if (!SWIG_IsOK(ecode1)) {
31342 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
31343 }
31344 arg1 = static_cast< bool >(val1);
31345 {
31346 PyThreadState* __tstate = wxPyBeginAllowThreads();
31347 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
31348 wxPyEndAllowThreads(__tstate);
31349 if (PyErr_Occurred()) SWIG_fail;
31350 }
31351 resultobj = SWIG_Py_Void();
31352 return resultobj;
31353 fail:
31354 return NULL;
31355 }
31356
31357
31358 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31359 PyObject *resultobj = 0;
31360 long arg1 ;
31361 long val1 ;
31362 int ecode1 = 0 ;
31363 PyObject * obj0 = 0 ;
31364 char * kwnames[] = {
31365 (char *) "val", NULL
31366 };
31367
31368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
31369 ecode1 = SWIG_AsVal_long(obj0, &val1);
31370 if (!SWIG_IsOK(ecode1)) {
31371 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
31372 }
31373 arg1 = static_cast< long >(val1);
31374 {
31375 PyThreadState* __tstate = wxPyBeginAllowThreads();
31376 wxPyApp::SetMacAboutMenuItemId(arg1);
31377 wxPyEndAllowThreads(__tstate);
31378 if (PyErr_Occurred()) SWIG_fail;
31379 }
31380 resultobj = SWIG_Py_Void();
31381 return resultobj;
31382 fail:
31383 return NULL;
31384 }
31385
31386
31387 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31388 PyObject *resultobj = 0;
31389 long arg1 ;
31390 long val1 ;
31391 int ecode1 = 0 ;
31392 PyObject * obj0 = 0 ;
31393 char * kwnames[] = {
31394 (char *) "val", NULL
31395 };
31396
31397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
31398 ecode1 = SWIG_AsVal_long(obj0, &val1);
31399 if (!SWIG_IsOK(ecode1)) {
31400 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
31401 }
31402 arg1 = static_cast< long >(val1);
31403 {
31404 PyThreadState* __tstate = wxPyBeginAllowThreads();
31405 wxPyApp::SetMacPreferencesMenuItemId(arg1);
31406 wxPyEndAllowThreads(__tstate);
31407 if (PyErr_Occurred()) SWIG_fail;
31408 }
31409 resultobj = SWIG_Py_Void();
31410 return resultobj;
31411 fail:
31412 return NULL;
31413 }
31414
31415
31416 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31417 PyObject *resultobj = 0;
31418 long arg1 ;
31419 long val1 ;
31420 int ecode1 = 0 ;
31421 PyObject * obj0 = 0 ;
31422 char * kwnames[] = {
31423 (char *) "val", NULL
31424 };
31425
31426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
31427 ecode1 = SWIG_AsVal_long(obj0, &val1);
31428 if (!SWIG_IsOK(ecode1)) {
31429 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
31430 }
31431 arg1 = static_cast< long >(val1);
31432 {
31433 PyThreadState* __tstate = wxPyBeginAllowThreads();
31434 wxPyApp::SetMacExitMenuItemId(arg1);
31435 wxPyEndAllowThreads(__tstate);
31436 if (PyErr_Occurred()) SWIG_fail;
31437 }
31438 resultobj = SWIG_Py_Void();
31439 return resultobj;
31440 fail:
31441 return NULL;
31442 }
31443
31444
31445 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31446 PyObject *resultobj = 0;
31447 wxString *arg1 = 0 ;
31448 bool temp1 = false ;
31449 PyObject * obj0 = 0 ;
31450 char * kwnames[] = {
31451 (char *) "val", NULL
31452 };
31453
31454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
31455 {
31456 arg1 = wxString_in_helper(obj0);
31457 if (arg1 == NULL) SWIG_fail;
31458 temp1 = true;
31459 }
31460 {
31461 PyThreadState* __tstate = wxPyBeginAllowThreads();
31462 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
31463 wxPyEndAllowThreads(__tstate);
31464 if (PyErr_Occurred()) SWIG_fail;
31465 }
31466 resultobj = SWIG_Py_Void();
31467 {
31468 if (temp1)
31469 delete arg1;
31470 }
31471 return resultobj;
31472 fail:
31473 {
31474 if (temp1)
31475 delete arg1;
31476 }
31477 return NULL;
31478 }
31479
31480
31481 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31482 PyObject *resultobj = 0;
31483 wxPyApp *arg1 = (wxPyApp *) 0 ;
31484 void *argp1 = 0 ;
31485 int res1 = 0 ;
31486 PyObject *swig_obj[1] ;
31487
31488 if (!args) SWIG_fail;
31489 swig_obj[0] = args;
31490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31491 if (!SWIG_IsOK(res1)) {
31492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
31493 }
31494 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31495 {
31496 PyThreadState* __tstate = wxPyBeginAllowThreads();
31497 (arg1)->_BootstrapApp();
31498 wxPyEndAllowThreads(__tstate);
31499 if (PyErr_Occurred()) SWIG_fail;
31500 }
31501 resultobj = SWIG_Py_Void();
31502 return resultobj;
31503 fail:
31504 return NULL;
31505 }
31506
31507
31508 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31509 PyObject *resultobj = 0;
31510 int result;
31511
31512 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
31513 {
31514 PyThreadState* __tstate = wxPyBeginAllowThreads();
31515 result = (int)wxPyApp_GetComCtl32Version();
31516 wxPyEndAllowThreads(__tstate);
31517 if (PyErr_Occurred()) SWIG_fail;
31518 }
31519 resultobj = SWIG_From_int(static_cast< int >(result));
31520 return resultobj;
31521 fail:
31522 return NULL;
31523 }
31524
31525
31526 SWIGINTERN PyObject *_wrap_PyApp_IsDisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31527 PyObject *resultobj = 0;
31528 bool result;
31529
31530 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsDisplayAvailable",0,0,0)) SWIG_fail;
31531 {
31532 PyThreadState* __tstate = wxPyBeginAllowThreads();
31533 result = (bool)wxPyApp_IsDisplayAvailable();
31534 wxPyEndAllowThreads(__tstate);
31535 if (PyErr_Occurred()) SWIG_fail;
31536 }
31537 {
31538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31539 }
31540 return resultobj;
31541 fail:
31542 return NULL;
31543 }
31544
31545
31546 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31547 PyObject *obj;
31548 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31549 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
31550 return SWIG_Py_Void();
31551 }
31552
31553 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31554 return SWIG_Python_InitShadowInstance(args);
31555 }
31556
31557 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31558 PyObject *resultobj = 0;
31559
31560 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
31561 {
31562 PyThreadState* __tstate = wxPyBeginAllowThreads();
31563 wxExit();
31564 wxPyEndAllowThreads(__tstate);
31565 if (PyErr_Occurred()) SWIG_fail;
31566 }
31567 resultobj = SWIG_Py_Void();
31568 return resultobj;
31569 fail:
31570 return NULL;
31571 }
31572
31573
31574 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31575 PyObject *resultobj = 0;
31576 bool result;
31577
31578 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
31579 {
31580 PyThreadState* __tstate = wxPyBeginAllowThreads();
31581 result = (bool)wxYield();
31582 wxPyEndAllowThreads(__tstate);
31583 if (PyErr_Occurred()) SWIG_fail;
31584 }
31585 {
31586 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31587 }
31588 return resultobj;
31589 fail:
31590 return NULL;
31591 }
31592
31593
31594 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31595 PyObject *resultobj = 0;
31596 bool result;
31597
31598 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
31599 {
31600 PyThreadState* __tstate = wxPyBeginAllowThreads();
31601 result = (bool)wxYieldIfNeeded();
31602 wxPyEndAllowThreads(__tstate);
31603 if (PyErr_Occurred()) SWIG_fail;
31604 }
31605 {
31606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31607 }
31608 return resultobj;
31609 fail:
31610 return NULL;
31611 }
31612
31613
31614 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31615 PyObject *resultobj = 0;
31616 wxWindow *arg1 = (wxWindow *) NULL ;
31617 bool arg2 = (bool) false ;
31618 bool result;
31619 void *argp1 = 0 ;
31620 int res1 = 0 ;
31621 bool val2 ;
31622 int ecode2 = 0 ;
31623 PyObject * obj0 = 0 ;
31624 PyObject * obj1 = 0 ;
31625 char * kwnames[] = {
31626 (char *) "win",(char *) "onlyIfNeeded", NULL
31627 };
31628
31629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
31630 if (obj0) {
31631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31632 if (!SWIG_IsOK(res1)) {
31633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
31634 }
31635 arg1 = reinterpret_cast< wxWindow * >(argp1);
31636 }
31637 if (obj1) {
31638 ecode2 = SWIG_AsVal_bool(obj1, &val2);
31639 if (!SWIG_IsOK(ecode2)) {
31640 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
31641 }
31642 arg2 = static_cast< bool >(val2);
31643 }
31644 {
31645 PyThreadState* __tstate = wxPyBeginAllowThreads();
31646 result = (bool)wxSafeYield(arg1,arg2);
31647 wxPyEndAllowThreads(__tstate);
31648 if (PyErr_Occurred()) SWIG_fail;
31649 }
31650 {
31651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31652 }
31653 return resultobj;
31654 fail:
31655 return NULL;
31656 }
31657
31658
31659 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31660 PyObject *resultobj = 0;
31661
31662 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
31663 {
31664 PyThreadState* __tstate = wxPyBeginAllowThreads();
31665 wxWakeUpIdle();
31666 wxPyEndAllowThreads(__tstate);
31667 if (PyErr_Occurred()) SWIG_fail;
31668 }
31669 resultobj = SWIG_Py_Void();
31670 return resultobj;
31671 fail:
31672 return NULL;
31673 }
31674
31675
31676 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31677 PyObject *resultobj = 0;
31678 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
31679 wxEvent *arg2 = 0 ;
31680 void *argp1 = 0 ;
31681 int res1 = 0 ;
31682 void *argp2 = 0 ;
31683 int res2 = 0 ;
31684 PyObject * obj0 = 0 ;
31685 PyObject * obj1 = 0 ;
31686 char * kwnames[] = {
31687 (char *) "dest",(char *) "event", NULL
31688 };
31689
31690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
31691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
31692 if (!SWIG_IsOK(res1)) {
31693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
31694 }
31695 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
31696 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
31697 if (!SWIG_IsOK(res2)) {
31698 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
31699 }
31700 if (!argp2) {
31701 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
31702 }
31703 arg2 = reinterpret_cast< wxEvent * >(argp2);
31704 {
31705 PyThreadState* __tstate = wxPyBeginAllowThreads();
31706 wxPostEvent(arg1,*arg2);
31707 wxPyEndAllowThreads(__tstate);
31708 if (PyErr_Occurred()) SWIG_fail;
31709 }
31710 resultobj = SWIG_Py_Void();
31711 return resultobj;
31712 fail:
31713 return NULL;
31714 }
31715
31716
31717 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31718 PyObject *resultobj = 0;
31719
31720 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
31721 {
31722 PyThreadState* __tstate = wxPyBeginAllowThreads();
31723 wxApp_CleanUp();
31724 wxPyEndAllowThreads(__tstate);
31725 if (PyErr_Occurred()) SWIG_fail;
31726 }
31727 resultobj = SWIG_Py_Void();
31728 return resultobj;
31729 fail:
31730 return NULL;
31731 }
31732
31733
31734 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31735 PyObject *resultobj = 0;
31736 wxPyApp *result = 0 ;
31737
31738 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
31739 {
31740 PyThreadState* __tstate = wxPyBeginAllowThreads();
31741 result = (wxPyApp *)wxPyGetApp();
31742 wxPyEndAllowThreads(__tstate);
31743 if (PyErr_Occurred()) SWIG_fail;
31744 }
31745 {
31746 resultobj = wxPyMake_wxObject(result, 0);
31747 }
31748 return resultobj;
31749 fail:
31750 return NULL;
31751 }
31752
31753
31754 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31755 PyObject *resultobj = 0;
31756 char *arg1 = (char *) 0 ;
31757 int res1 ;
31758 char *buf1 = 0 ;
31759 int alloc1 = 0 ;
31760 PyObject * obj0 = 0 ;
31761 char * kwnames[] = {
31762 (char *) "encoding", NULL
31763 };
31764
31765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
31766 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
31767 if (!SWIG_IsOK(res1)) {
31768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
31769 }
31770 arg1 = buf1;
31771 {
31772 PyThreadState* __tstate = wxPyBeginAllowThreads();
31773 wxSetDefaultPyEncoding((char const *)arg1);
31774 wxPyEndAllowThreads(__tstate);
31775 if (PyErr_Occurred()) SWIG_fail;
31776 }
31777 resultobj = SWIG_Py_Void();
31778 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
31779 return resultobj;
31780 fail:
31781 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
31782 return NULL;
31783 }
31784
31785
31786 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31787 PyObject *resultobj = 0;
31788 char *result = 0 ;
31789
31790 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
31791 {
31792 PyThreadState* __tstate = wxPyBeginAllowThreads();
31793 result = (char *)wxGetDefaultPyEncoding();
31794 wxPyEndAllowThreads(__tstate);
31795 if (PyErr_Occurred()) SWIG_fail;
31796 }
31797 resultobj = SWIG_FromCharPtr(result);
31798 return resultobj;
31799 fail:
31800 return NULL;
31801 }
31802
31803
31804 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31805 PyObject *resultobj = 0;
31806 wxEventLoop *result = 0 ;
31807
31808 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
31809 {
31810 PyThreadState* __tstate = wxPyBeginAllowThreads();
31811 result = (wxEventLoop *)new wxEventLoop();
31812 wxPyEndAllowThreads(__tstate);
31813 if (PyErr_Occurred()) SWIG_fail;
31814 }
31815 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
31816 return resultobj;
31817 fail:
31818 return NULL;
31819 }
31820
31821
31822 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31823 PyObject *resultobj = 0;
31824 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31825 void *argp1 = 0 ;
31826 int res1 = 0 ;
31827 PyObject *swig_obj[1] ;
31828
31829 if (!args) SWIG_fail;
31830 swig_obj[0] = args;
31831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
31832 if (!SWIG_IsOK(res1)) {
31833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31834 }
31835 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31836 {
31837 PyThreadState* __tstate = wxPyBeginAllowThreads();
31838 delete arg1;
31839
31840 wxPyEndAllowThreads(__tstate);
31841 if (PyErr_Occurred()) SWIG_fail;
31842 }
31843 resultobj = SWIG_Py_Void();
31844 return resultobj;
31845 fail:
31846 return NULL;
31847 }
31848
31849
31850 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31851 PyObject *resultobj = 0;
31852 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31853 int result;
31854 void *argp1 = 0 ;
31855 int res1 = 0 ;
31856 PyObject *swig_obj[1] ;
31857
31858 if (!args) SWIG_fail;
31859 swig_obj[0] = args;
31860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31861 if (!SWIG_IsOK(res1)) {
31862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31863 }
31864 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31865 {
31866 PyThreadState* __tstate = wxPyBeginAllowThreads();
31867 result = (int)(arg1)->Run();
31868 wxPyEndAllowThreads(__tstate);
31869 if (PyErr_Occurred()) SWIG_fail;
31870 }
31871 resultobj = SWIG_From_int(static_cast< int >(result));
31872 return resultobj;
31873 fail:
31874 return NULL;
31875 }
31876
31877
31878 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31879 PyObject *resultobj = 0;
31880 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31881 int arg2 = (int) 0 ;
31882 void *argp1 = 0 ;
31883 int res1 = 0 ;
31884 int val2 ;
31885 int ecode2 = 0 ;
31886 PyObject * obj0 = 0 ;
31887 PyObject * obj1 = 0 ;
31888 char * kwnames[] = {
31889 (char *) "self",(char *) "rc", NULL
31890 };
31891
31892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
31893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31894 if (!SWIG_IsOK(res1)) {
31895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31896 }
31897 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31898 if (obj1) {
31899 ecode2 = SWIG_AsVal_int(obj1, &val2);
31900 if (!SWIG_IsOK(ecode2)) {
31901 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
31902 }
31903 arg2 = static_cast< int >(val2);
31904 }
31905 {
31906 PyThreadState* __tstate = wxPyBeginAllowThreads();
31907 (arg1)->Exit(arg2);
31908 wxPyEndAllowThreads(__tstate);
31909 if (PyErr_Occurred()) SWIG_fail;
31910 }
31911 resultobj = SWIG_Py_Void();
31912 return resultobj;
31913 fail:
31914 return NULL;
31915 }
31916
31917
31918 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31919 PyObject *resultobj = 0;
31920 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31921 bool result;
31922 void *argp1 = 0 ;
31923 int res1 = 0 ;
31924 PyObject *swig_obj[1] ;
31925
31926 if (!args) SWIG_fail;
31927 swig_obj[0] = args;
31928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31929 if (!SWIG_IsOK(res1)) {
31930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
31931 }
31932 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31933 {
31934 PyThreadState* __tstate = wxPyBeginAllowThreads();
31935 result = (bool)((wxEventLoop const *)arg1)->Pending();
31936 wxPyEndAllowThreads(__tstate);
31937 if (PyErr_Occurred()) SWIG_fail;
31938 }
31939 {
31940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31941 }
31942 return resultobj;
31943 fail:
31944 return NULL;
31945 }
31946
31947
31948 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31949 PyObject *resultobj = 0;
31950 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31951 bool result;
31952 void *argp1 = 0 ;
31953 int res1 = 0 ;
31954 PyObject *swig_obj[1] ;
31955
31956 if (!args) SWIG_fail;
31957 swig_obj[0] = args;
31958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31959 if (!SWIG_IsOK(res1)) {
31960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31961 }
31962 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31963 {
31964 PyThreadState* __tstate = wxPyBeginAllowThreads();
31965 result = (bool)(arg1)->Dispatch();
31966 wxPyEndAllowThreads(__tstate);
31967 if (PyErr_Occurred()) SWIG_fail;
31968 }
31969 {
31970 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31971 }
31972 return resultobj;
31973 fail:
31974 return NULL;
31975 }
31976
31977
31978 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31979 PyObject *resultobj = 0;
31980 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31981 bool result;
31982 void *argp1 = 0 ;
31983 int res1 = 0 ;
31984 PyObject *swig_obj[1] ;
31985
31986 if (!args) SWIG_fail;
31987 swig_obj[0] = args;
31988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31989 if (!SWIG_IsOK(res1)) {
31990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
31991 }
31992 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31993 {
31994 PyThreadState* __tstate = wxPyBeginAllowThreads();
31995 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
31996 wxPyEndAllowThreads(__tstate);
31997 if (PyErr_Occurred()) SWIG_fail;
31998 }
31999 {
32000 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32001 }
32002 return resultobj;
32003 fail:
32004 return NULL;
32005 }
32006
32007
32008 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32009 PyObject *resultobj = 0;
32010 wxEventLoop *result = 0 ;
32011
32012 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
32013 {
32014 PyThreadState* __tstate = wxPyBeginAllowThreads();
32015 result = (wxEventLoop *)wxEventLoop::GetActive();
32016 wxPyEndAllowThreads(__tstate);
32017 if (PyErr_Occurred()) SWIG_fail;
32018 }
32019 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
32020 return resultobj;
32021 fail:
32022 return NULL;
32023 }
32024
32025
32026 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32027 PyObject *resultobj = 0;
32028 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
32029 void *argp1 = 0 ;
32030 int res1 = 0 ;
32031 PyObject * obj0 = 0 ;
32032 char * kwnames[] = {
32033 (char *) "loop", NULL
32034 };
32035
32036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
32037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
32038 if (!SWIG_IsOK(res1)) {
32039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
32040 }
32041 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
32042 {
32043 PyThreadState* __tstate = wxPyBeginAllowThreads();
32044 wxEventLoop::SetActive(arg1);
32045 wxPyEndAllowThreads(__tstate);
32046 if (PyErr_Occurred()) SWIG_fail;
32047 }
32048 resultobj = SWIG_Py_Void();
32049 return resultobj;
32050 fail:
32051 return NULL;
32052 }
32053
32054
32055 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32056 PyObject *obj;
32057 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32058 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
32059 return SWIG_Py_Void();
32060 }
32061
32062 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32063 return SWIG_Python_InitShadowInstance(args);
32064 }
32065
32066 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32067 PyObject *resultobj = 0;
32068 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
32069 wxEventLoopActivator *result = 0 ;
32070 void *argp1 = 0 ;
32071 int res1 = 0 ;
32072 PyObject * obj0 = 0 ;
32073 char * kwnames[] = {
32074 (char *) "evtLoop", NULL
32075 };
32076
32077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
32078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
32079 if (!SWIG_IsOK(res1)) {
32080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
32081 }
32082 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
32083 {
32084 PyThreadState* __tstate = wxPyBeginAllowThreads();
32085 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
32086 wxPyEndAllowThreads(__tstate);
32087 if (PyErr_Occurred()) SWIG_fail;
32088 }
32089 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
32090 return resultobj;
32091 fail:
32092 return NULL;
32093 }
32094
32095
32096 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32097 PyObject *resultobj = 0;
32098 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
32099 void *argp1 = 0 ;
32100 int res1 = 0 ;
32101 PyObject *swig_obj[1] ;
32102
32103 if (!args) SWIG_fail;
32104 swig_obj[0] = args;
32105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
32106 if (!SWIG_IsOK(res1)) {
32107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
32108 }
32109 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
32110 {
32111 PyThreadState* __tstate = wxPyBeginAllowThreads();
32112 delete arg1;
32113
32114 wxPyEndAllowThreads(__tstate);
32115 if (PyErr_Occurred()) SWIG_fail;
32116 }
32117 resultobj = SWIG_Py_Void();
32118 return resultobj;
32119 fail:
32120 return NULL;
32121 }
32122
32123
32124 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32125 PyObject *obj;
32126 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32127 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
32128 return SWIG_Py_Void();
32129 }
32130
32131 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32132 return SWIG_Python_InitShadowInstance(args);
32133 }
32134
32135 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32136 PyObject *resultobj = 0;
32137 int arg1 = (int) 0 ;
32138 int arg2 = (int) 0 ;
32139 int arg3 = (int) 0 ;
32140 wxAcceleratorEntry *result = 0 ;
32141 int val1 ;
32142 int ecode1 = 0 ;
32143 int val2 ;
32144 int ecode2 = 0 ;
32145 int val3 ;
32146 int ecode3 = 0 ;
32147 PyObject * obj0 = 0 ;
32148 PyObject * obj1 = 0 ;
32149 PyObject * obj2 = 0 ;
32150 char * kwnames[] = {
32151 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
32152 };
32153
32154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32155 if (obj0) {
32156 ecode1 = SWIG_AsVal_int(obj0, &val1);
32157 if (!SWIG_IsOK(ecode1)) {
32158 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
32159 }
32160 arg1 = static_cast< int >(val1);
32161 }
32162 if (obj1) {
32163 ecode2 = SWIG_AsVal_int(obj1, &val2);
32164 if (!SWIG_IsOK(ecode2)) {
32165 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
32166 }
32167 arg2 = static_cast< int >(val2);
32168 }
32169 if (obj2) {
32170 ecode3 = SWIG_AsVal_int(obj2, &val3);
32171 if (!SWIG_IsOK(ecode3)) {
32172 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
32173 }
32174 arg3 = static_cast< int >(val3);
32175 }
32176 {
32177 PyThreadState* __tstate = wxPyBeginAllowThreads();
32178 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
32179 wxPyEndAllowThreads(__tstate);
32180 if (PyErr_Occurred()) SWIG_fail;
32181 }
32182 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
32183 return resultobj;
32184 fail:
32185 return NULL;
32186 }
32187
32188
32189 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32190 PyObject *resultobj = 0;
32191 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32192 void *argp1 = 0 ;
32193 int res1 = 0 ;
32194 PyObject *swig_obj[1] ;
32195
32196 if (!args) SWIG_fail;
32197 swig_obj[0] = args;
32198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
32199 if (!SWIG_IsOK(res1)) {
32200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32201 }
32202 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32203 {
32204 PyThreadState* __tstate = wxPyBeginAllowThreads();
32205 delete arg1;
32206
32207 wxPyEndAllowThreads(__tstate);
32208 if (PyErr_Occurred()) SWIG_fail;
32209 }
32210 resultobj = SWIG_Py_Void();
32211 return resultobj;
32212 fail:
32213 return NULL;
32214 }
32215
32216
32217 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32218 PyObject *resultobj = 0;
32219 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32220 int arg2 ;
32221 int arg3 ;
32222 int arg4 ;
32223 void *argp1 = 0 ;
32224 int res1 = 0 ;
32225 int val2 ;
32226 int ecode2 = 0 ;
32227 int val3 ;
32228 int ecode3 = 0 ;
32229 int val4 ;
32230 int ecode4 = 0 ;
32231 PyObject * obj0 = 0 ;
32232 PyObject * obj1 = 0 ;
32233 PyObject * obj2 = 0 ;
32234 PyObject * obj3 = 0 ;
32235 char * kwnames[] = {
32236 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
32237 };
32238
32239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32241 if (!SWIG_IsOK(res1)) {
32242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32243 }
32244 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32245 ecode2 = SWIG_AsVal_int(obj1, &val2);
32246 if (!SWIG_IsOK(ecode2)) {
32247 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
32248 }
32249 arg2 = static_cast< int >(val2);
32250 ecode3 = SWIG_AsVal_int(obj2, &val3);
32251 if (!SWIG_IsOK(ecode3)) {
32252 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
32253 }
32254 arg3 = static_cast< int >(val3);
32255 ecode4 = SWIG_AsVal_int(obj3, &val4);
32256 if (!SWIG_IsOK(ecode4)) {
32257 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
32258 }
32259 arg4 = static_cast< int >(val4);
32260 {
32261 PyThreadState* __tstate = wxPyBeginAllowThreads();
32262 (arg1)->Set(arg2,arg3,arg4);
32263 wxPyEndAllowThreads(__tstate);
32264 if (PyErr_Occurred()) SWIG_fail;
32265 }
32266 resultobj = SWIG_Py_Void();
32267 return resultobj;
32268 fail:
32269 return NULL;
32270 }
32271
32272
32273 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32274 PyObject *resultobj = 0;
32275 wxString *arg1 = 0 ;
32276 wxAcceleratorEntry *result = 0 ;
32277 bool temp1 = false ;
32278 PyObject * obj0 = 0 ;
32279 char * kwnames[] = {
32280 (char *) "str", NULL
32281 };
32282
32283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_Create",kwnames,&obj0)) SWIG_fail;
32284 {
32285 arg1 = wxString_in_helper(obj0);
32286 if (arg1 == NULL) SWIG_fail;
32287 temp1 = true;
32288 }
32289 {
32290 PyThreadState* __tstate = wxPyBeginAllowThreads();
32291 result = (wxAcceleratorEntry *)wxAcceleratorEntry::Create((wxString const &)*arg1);
32292 wxPyEndAllowThreads(__tstate);
32293 if (PyErr_Occurred()) SWIG_fail;
32294 }
32295 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_OWN | 0 );
32296 {
32297 if (temp1)
32298 delete arg1;
32299 }
32300 return resultobj;
32301 fail:
32302 {
32303 if (temp1)
32304 delete arg1;
32305 }
32306 return NULL;
32307 }
32308
32309
32310 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32311 PyObject *resultobj = 0;
32312 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32313 int result;
32314 void *argp1 = 0 ;
32315 int res1 = 0 ;
32316 PyObject *swig_obj[1] ;
32317
32318 if (!args) SWIG_fail;
32319 swig_obj[0] = args;
32320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32321 if (!SWIG_IsOK(res1)) {
32322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32323 }
32324 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32325 {
32326 PyThreadState* __tstate = wxPyBeginAllowThreads();
32327 result = (int)(arg1)->GetFlags();
32328 wxPyEndAllowThreads(__tstate);
32329 if (PyErr_Occurred()) SWIG_fail;
32330 }
32331 resultobj = SWIG_From_int(static_cast< int >(result));
32332 return resultobj;
32333 fail:
32334 return NULL;
32335 }
32336
32337
32338 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32339 PyObject *resultobj = 0;
32340 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32341 int result;
32342 void *argp1 = 0 ;
32343 int res1 = 0 ;
32344 PyObject *swig_obj[1] ;
32345
32346 if (!args) SWIG_fail;
32347 swig_obj[0] = args;
32348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32349 if (!SWIG_IsOK(res1)) {
32350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32351 }
32352 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32353 {
32354 PyThreadState* __tstate = wxPyBeginAllowThreads();
32355 result = (int)(arg1)->GetKeyCode();
32356 wxPyEndAllowThreads(__tstate);
32357 if (PyErr_Occurred()) SWIG_fail;
32358 }
32359 resultobj = SWIG_From_int(static_cast< int >(result));
32360 return resultobj;
32361 fail:
32362 return NULL;
32363 }
32364
32365
32366 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32367 PyObject *resultobj = 0;
32368 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32369 int result;
32370 void *argp1 = 0 ;
32371 int res1 = 0 ;
32372 PyObject *swig_obj[1] ;
32373
32374 if (!args) SWIG_fail;
32375 swig_obj[0] = args;
32376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32377 if (!SWIG_IsOK(res1)) {
32378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32379 }
32380 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32381 {
32382 PyThreadState* __tstate = wxPyBeginAllowThreads();
32383 result = (int)(arg1)->GetCommand();
32384 wxPyEndAllowThreads(__tstate);
32385 if (PyErr_Occurred()) SWIG_fail;
32386 }
32387 resultobj = SWIG_From_int(static_cast< int >(result));
32388 return resultobj;
32389 fail:
32390 return NULL;
32391 }
32392
32393
32394 SWIGINTERN PyObject *_wrap_AcceleratorEntry_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32395 PyObject *resultobj = 0;
32396 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32397 bool result;
32398 void *argp1 = 0 ;
32399 int res1 = 0 ;
32400 PyObject *swig_obj[1] ;
32401
32402 if (!args) SWIG_fail;
32403 swig_obj[0] = args;
32404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32405 if (!SWIG_IsOK(res1)) {
32406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32407 }
32408 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32409 {
32410 PyThreadState* __tstate = wxPyBeginAllowThreads();
32411 result = (bool)((wxAcceleratorEntry const *)arg1)->IsOk();
32412 wxPyEndAllowThreads(__tstate);
32413 if (PyErr_Occurred()) SWIG_fail;
32414 }
32415 {
32416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32417 }
32418 return resultobj;
32419 fail:
32420 return NULL;
32421 }
32422
32423
32424 SWIGINTERN PyObject *_wrap_AcceleratorEntry_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32425 PyObject *resultobj = 0;
32426 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32427 wxString result;
32428 void *argp1 = 0 ;
32429 int res1 = 0 ;
32430 PyObject *swig_obj[1] ;
32431
32432 if (!args) SWIG_fail;
32433 swig_obj[0] = args;
32434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32435 if (!SWIG_IsOK(res1)) {
32436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_ToString" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32437 }
32438 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32439 {
32440 PyThreadState* __tstate = wxPyBeginAllowThreads();
32441 result = ((wxAcceleratorEntry const *)arg1)->ToString();
32442 wxPyEndAllowThreads(__tstate);
32443 if (PyErr_Occurred()) SWIG_fail;
32444 }
32445 {
32446 #if wxUSE_UNICODE
32447 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32448 #else
32449 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32450 #endif
32451 }
32452 return resultobj;
32453 fail:
32454 return NULL;
32455 }
32456
32457
32458 SWIGINTERN PyObject *_wrap_AcceleratorEntry_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32459 PyObject *resultobj = 0;
32460 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32461 wxString *arg2 = 0 ;
32462 bool result;
32463 void *argp1 = 0 ;
32464 int res1 = 0 ;
32465 bool temp2 = false ;
32466 PyObject * obj0 = 0 ;
32467 PyObject * obj1 = 0 ;
32468 char * kwnames[] = {
32469 (char *) "self",(char *) "str", NULL
32470 };
32471
32472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AcceleratorEntry_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
32473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32474 if (!SWIG_IsOK(res1)) {
32475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_FromString" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32476 }
32477 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32478 {
32479 arg2 = wxString_in_helper(obj1);
32480 if (arg2 == NULL) SWIG_fail;
32481 temp2 = true;
32482 }
32483 {
32484 PyThreadState* __tstate = wxPyBeginAllowThreads();
32485 result = (bool)(arg1)->FromString((wxString const &)*arg2);
32486 wxPyEndAllowThreads(__tstate);
32487 if (PyErr_Occurred()) SWIG_fail;
32488 }
32489 {
32490 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32491 }
32492 {
32493 if (temp2)
32494 delete arg2;
32495 }
32496 return resultobj;
32497 fail:
32498 {
32499 if (temp2)
32500 delete arg2;
32501 }
32502 return NULL;
32503 }
32504
32505
32506 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32507 PyObject *obj;
32508 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32509 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
32510 return SWIG_Py_Void();
32511 }
32512
32513 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32514 return SWIG_Python_InitShadowInstance(args);
32515 }
32516
32517 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32518 PyObject *resultobj = 0;
32519 int arg1 ;
32520 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
32521 wxAcceleratorTable *result = 0 ;
32522 PyObject * obj0 = 0 ;
32523 char * kwnames[] = {
32524 (char *) "n", NULL
32525 };
32526
32527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
32528 {
32529 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
32530 if (arg2) arg1 = PyList_Size(obj0);
32531 else arg1 = 0;
32532 }
32533 {
32534 PyThreadState* __tstate = wxPyBeginAllowThreads();
32535 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
32536 wxPyEndAllowThreads(__tstate);
32537 if (PyErr_Occurred()) SWIG_fail;
32538 }
32539 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
32540 return resultobj;
32541 fail:
32542 return NULL;
32543 }
32544
32545
32546 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32547 PyObject *resultobj = 0;
32548 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
32549 void *argp1 = 0 ;
32550 int res1 = 0 ;
32551 PyObject *swig_obj[1] ;
32552
32553 if (!args) SWIG_fail;
32554 swig_obj[0] = args;
32555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
32556 if (!SWIG_IsOK(res1)) {
32557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
32558 }
32559 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
32560 {
32561 PyThreadState* __tstate = wxPyBeginAllowThreads();
32562 delete arg1;
32563
32564 wxPyEndAllowThreads(__tstate);
32565 if (PyErr_Occurred()) SWIG_fail;
32566 }
32567 resultobj = SWIG_Py_Void();
32568 return resultobj;
32569 fail:
32570 return NULL;
32571 }
32572
32573
32574 SWIGINTERN PyObject *_wrap_AcceleratorTable_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32575 PyObject *resultobj = 0;
32576 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
32577 bool result;
32578 void *argp1 = 0 ;
32579 int res1 = 0 ;
32580 PyObject *swig_obj[1] ;
32581
32582 if (!args) SWIG_fail;
32583 swig_obj[0] = args;
32584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
32585 if (!SWIG_IsOK(res1)) {
32586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
32587 }
32588 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
32589 {
32590 PyThreadState* __tstate = wxPyBeginAllowThreads();
32591 result = (bool)((wxAcceleratorTable const *)arg1)->IsOk();
32592 wxPyEndAllowThreads(__tstate);
32593 if (PyErr_Occurred()) SWIG_fail;
32594 }
32595 {
32596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32597 }
32598 return resultobj;
32599 fail:
32600 return NULL;
32601 }
32602
32603
32604 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32605 PyObject *obj;
32606 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32607 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
32608 return SWIG_Py_Void();
32609 }
32610
32611 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32612 return SWIG_Python_InitShadowInstance(args);
32613 }
32614
32615 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
32616 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
32617 return 1;
32618 }
32619
32620
32621 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
32622 PyObject *pyobj = 0;
32623
32624 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
32625 return pyobj;
32626 }
32627
32628
32629 SWIGINTERN int PanelNameStr_set(PyObject *) {
32630 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
32631 return 1;
32632 }
32633
32634
32635 SWIGINTERN PyObject *PanelNameStr_get(void) {
32636 PyObject *pyobj = 0;
32637
32638 {
32639 #if wxUSE_UNICODE
32640 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
32641 #else
32642 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
32643 #endif
32644 }
32645 return pyobj;
32646 }
32647
32648
32649 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32650 PyObject *resultobj = 0;
32651 wxVisualAttributes *result = 0 ;
32652
32653 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
32654 {
32655 PyThreadState* __tstate = wxPyBeginAllowThreads();
32656 result = (wxVisualAttributes *)new_wxVisualAttributes();
32657 wxPyEndAllowThreads(__tstate);
32658 if (PyErr_Occurred()) SWIG_fail;
32659 }
32660 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
32661 return resultobj;
32662 fail:
32663 return NULL;
32664 }
32665
32666
32667 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32668 PyObject *resultobj = 0;
32669 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32670 void *argp1 = 0 ;
32671 int res1 = 0 ;
32672 PyObject *swig_obj[1] ;
32673
32674 if (!args) SWIG_fail;
32675 swig_obj[0] = args;
32676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
32677 if (!SWIG_IsOK(res1)) {
32678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32679 }
32680 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32681 {
32682 PyThreadState* __tstate = wxPyBeginAllowThreads();
32683 delete_wxVisualAttributes(arg1);
32684
32685 wxPyEndAllowThreads(__tstate);
32686 if (PyErr_Occurred()) SWIG_fail;
32687 }
32688 resultobj = SWIG_Py_Void();
32689 return resultobj;
32690 fail:
32691 return NULL;
32692 }
32693
32694
32695 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32696 PyObject *resultobj = 0;
32697 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32698 wxFont *arg2 = (wxFont *) 0 ;
32699 void *argp1 = 0 ;
32700 int res1 = 0 ;
32701 void *argp2 = 0 ;
32702 int res2 = 0 ;
32703 PyObject *swig_obj[2] ;
32704
32705 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
32706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32707 if (!SWIG_IsOK(res1)) {
32708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32709 }
32710 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32711 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
32712 if (!SWIG_IsOK(res2)) {
32713 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
32714 }
32715 arg2 = reinterpret_cast< wxFont * >(argp2);
32716 if (arg1) (arg1)->font = *arg2;
32717
32718 resultobj = SWIG_Py_Void();
32719 return resultobj;
32720 fail:
32721 return NULL;
32722 }
32723
32724
32725 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32726 PyObject *resultobj = 0;
32727 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32728 wxFont *result = 0 ;
32729 void *argp1 = 0 ;
32730 int res1 = 0 ;
32731 PyObject *swig_obj[1] ;
32732
32733 if (!args) SWIG_fail;
32734 swig_obj[0] = args;
32735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32736 if (!SWIG_IsOK(res1)) {
32737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32738 }
32739 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32740 result = (wxFont *)& ((arg1)->font);
32741 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
32742 return resultobj;
32743 fail:
32744 return NULL;
32745 }
32746
32747
32748 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32749 PyObject *resultobj = 0;
32750 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32751 wxColour *arg2 = (wxColour *) 0 ;
32752 void *argp1 = 0 ;
32753 int res1 = 0 ;
32754 void *argp2 = 0 ;
32755 int res2 = 0 ;
32756 PyObject *swig_obj[2] ;
32757
32758 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
32759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32760 if (!SWIG_IsOK(res1)) {
32761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32762 }
32763 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32764 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
32765 if (!SWIG_IsOK(res2)) {
32766 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
32767 }
32768 arg2 = reinterpret_cast< wxColour * >(argp2);
32769 if (arg1) (arg1)->colFg = *arg2;
32770
32771 resultobj = SWIG_Py_Void();
32772 return resultobj;
32773 fail:
32774 return NULL;
32775 }
32776
32777
32778 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32779 PyObject *resultobj = 0;
32780 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32781 wxColour *result = 0 ;
32782 void *argp1 = 0 ;
32783 int res1 = 0 ;
32784 PyObject *swig_obj[1] ;
32785
32786 if (!args) SWIG_fail;
32787 swig_obj[0] = args;
32788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32789 if (!SWIG_IsOK(res1)) {
32790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32791 }
32792 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32793 result = (wxColour *)& ((arg1)->colFg);
32794 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
32795 return resultobj;
32796 fail:
32797 return NULL;
32798 }
32799
32800
32801 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32802 PyObject *resultobj = 0;
32803 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32804 wxColour *arg2 = (wxColour *) 0 ;
32805 void *argp1 = 0 ;
32806 int res1 = 0 ;
32807 void *argp2 = 0 ;
32808 int res2 = 0 ;
32809 PyObject *swig_obj[2] ;
32810
32811 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
32812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32813 if (!SWIG_IsOK(res1)) {
32814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32815 }
32816 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32817 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
32818 if (!SWIG_IsOK(res2)) {
32819 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
32820 }
32821 arg2 = reinterpret_cast< wxColour * >(argp2);
32822 if (arg1) (arg1)->colBg = *arg2;
32823
32824 resultobj = SWIG_Py_Void();
32825 return resultobj;
32826 fail:
32827 return NULL;
32828 }
32829
32830
32831 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32832 PyObject *resultobj = 0;
32833 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32834 wxColour *result = 0 ;
32835 void *argp1 = 0 ;
32836 int res1 = 0 ;
32837 PyObject *swig_obj[1] ;
32838
32839 if (!args) SWIG_fail;
32840 swig_obj[0] = args;
32841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32842 if (!SWIG_IsOK(res1)) {
32843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32844 }
32845 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32846 result = (wxColour *)& ((arg1)->colBg);
32847 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
32848 return resultobj;
32849 fail:
32850 return NULL;
32851 }
32852
32853
32854 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32855 PyObject *obj;
32856 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32857 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
32858 return SWIG_Py_Void();
32859 }
32860
32861 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32862 return SWIG_Python_InitShadowInstance(args);
32863 }
32864
32865 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32866 PyObject *resultobj = 0;
32867 wxWindow *arg1 = (wxWindow *) 0 ;
32868 int arg2 = (int) (int)-1 ;
32869 wxPoint const &arg3_defvalue = wxDefaultPosition ;
32870 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
32871 wxSize const &arg4_defvalue = wxDefaultSize ;
32872 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
32873 long arg5 = (long) 0 ;
32874 wxString const &arg6_defvalue = wxPyPanelNameStr ;
32875 wxString *arg6 = (wxString *) &arg6_defvalue ;
32876 wxWindow *result = 0 ;
32877 void *argp1 = 0 ;
32878 int res1 = 0 ;
32879 int val2 ;
32880 int ecode2 = 0 ;
32881 wxPoint temp3 ;
32882 wxSize temp4 ;
32883 long val5 ;
32884 int ecode5 = 0 ;
32885 bool temp6 = false ;
32886 PyObject * obj0 = 0 ;
32887 PyObject * obj1 = 0 ;
32888 PyObject * obj2 = 0 ;
32889 PyObject * obj3 = 0 ;
32890 PyObject * obj4 = 0 ;
32891 PyObject * obj5 = 0 ;
32892 char * kwnames[] = {
32893 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
32894 };
32895
32896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
32897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32898 if (!SWIG_IsOK(res1)) {
32899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
32900 }
32901 arg1 = reinterpret_cast< wxWindow * >(argp1);
32902 if (obj1) {
32903 ecode2 = SWIG_AsVal_int(obj1, &val2);
32904 if (!SWIG_IsOK(ecode2)) {
32905 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
32906 }
32907 arg2 = static_cast< int >(val2);
32908 }
32909 if (obj2) {
32910 {
32911 arg3 = &temp3;
32912 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
32913 }
32914 }
32915 if (obj3) {
32916 {
32917 arg4 = &temp4;
32918 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
32919 }
32920 }
32921 if (obj4) {
32922 ecode5 = SWIG_AsVal_long(obj4, &val5);
32923 if (!SWIG_IsOK(ecode5)) {
32924 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
32925 }
32926 arg5 = static_cast< long >(val5);
32927 }
32928 if (obj5) {
32929 {
32930 arg6 = wxString_in_helper(obj5);
32931 if (arg6 == NULL) SWIG_fail;
32932 temp6 = true;
32933 }
32934 }
32935 {
32936 if (!wxPyCheckForApp()) SWIG_fail;
32937 PyThreadState* __tstate = wxPyBeginAllowThreads();
32938 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
32939 wxPyEndAllowThreads(__tstate);
32940 if (PyErr_Occurred()) SWIG_fail;
32941 }
32942 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
32943 {
32944 if (temp6)
32945 delete arg6;
32946 }
32947 return resultobj;
32948 fail:
32949 {
32950 if (temp6)
32951 delete arg6;
32952 }
32953 return NULL;
32954 }
32955
32956
32957 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32958 PyObject *resultobj = 0;
32959 wxWindow *result = 0 ;
32960
32961 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
32962 {
32963 if (!wxPyCheckForApp()) SWIG_fail;
32964 PyThreadState* __tstate = wxPyBeginAllowThreads();
32965 result = (wxWindow *)new wxWindow();
32966 wxPyEndAllowThreads(__tstate);
32967 if (PyErr_Occurred()) SWIG_fail;
32968 }
32969 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
32970 return resultobj;
32971 fail:
32972 return NULL;
32973 }
32974
32975
32976 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32977 PyObject *resultobj = 0;
32978 wxWindow *arg1 = (wxWindow *) 0 ;
32979 wxWindow *arg2 = (wxWindow *) 0 ;
32980 int arg3 = (int) (int)-1 ;
32981 wxPoint const &arg4_defvalue = wxDefaultPosition ;
32982 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
32983 wxSize const &arg5_defvalue = wxDefaultSize ;
32984 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
32985 long arg6 = (long) 0 ;
32986 wxString const &arg7_defvalue = wxPyPanelNameStr ;
32987 wxString *arg7 = (wxString *) &arg7_defvalue ;
32988 bool result;
32989 void *argp1 = 0 ;
32990 int res1 = 0 ;
32991 void *argp2 = 0 ;
32992 int res2 = 0 ;
32993 int val3 ;
32994 int ecode3 = 0 ;
32995 wxPoint temp4 ;
32996 wxSize temp5 ;
32997 long val6 ;
32998 int ecode6 = 0 ;
32999 bool temp7 = false ;
33000 PyObject * obj0 = 0 ;
33001 PyObject * obj1 = 0 ;
33002 PyObject * obj2 = 0 ;
33003 PyObject * obj3 = 0 ;
33004 PyObject * obj4 = 0 ;
33005 PyObject * obj5 = 0 ;
33006 PyObject * obj6 = 0 ;
33007 char * kwnames[] = {
33008 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
33009 };
33010
33011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
33012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33013 if (!SWIG_IsOK(res1)) {
33014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
33015 }
33016 arg1 = reinterpret_cast< wxWindow * >(argp1);
33017 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33018 if (!SWIG_IsOK(res2)) {
33019 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
33020 }
33021 arg2 = reinterpret_cast< wxWindow * >(argp2);
33022 if (obj2) {
33023 ecode3 = SWIG_AsVal_int(obj2, &val3);
33024 if (!SWIG_IsOK(ecode3)) {
33025 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
33026 }
33027 arg3 = static_cast< int >(val3);
33028 }
33029 if (obj3) {
33030 {
33031 arg4 = &temp4;
33032 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
33033 }
33034 }
33035 if (obj4) {
33036 {
33037 arg5 = &temp5;
33038 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
33039 }
33040 }
33041 if (obj5) {
33042 ecode6 = SWIG_AsVal_long(obj5, &val6);
33043 if (!SWIG_IsOK(ecode6)) {
33044 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
33045 }
33046 arg6 = static_cast< long >(val6);
33047 }
33048 if (obj6) {
33049 {
33050 arg7 = wxString_in_helper(obj6);
33051 if (arg7 == NULL) SWIG_fail;
33052 temp7 = true;
33053 }
33054 }
33055 {
33056 PyThreadState* __tstate = wxPyBeginAllowThreads();
33057 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
33058 wxPyEndAllowThreads(__tstate);
33059 if (PyErr_Occurred()) SWIG_fail;
33060 }
33061 {
33062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33063 }
33064 {
33065 if (temp7)
33066 delete arg7;
33067 }
33068 return resultobj;
33069 fail:
33070 {
33071 if (temp7)
33072 delete arg7;
33073 }
33074 return NULL;
33075 }
33076
33077
33078 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33079 PyObject *resultobj = 0;
33080 wxWindow *arg1 = (wxWindow *) 0 ;
33081 bool arg2 = (bool) false ;
33082 bool result;
33083 void *argp1 = 0 ;
33084 int res1 = 0 ;
33085 bool val2 ;
33086 int ecode2 = 0 ;
33087 PyObject * obj0 = 0 ;
33088 PyObject * obj1 = 0 ;
33089 char * kwnames[] = {
33090 (char *) "self",(char *) "force", NULL
33091 };
33092
33093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
33094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33095 if (!SWIG_IsOK(res1)) {
33096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
33097 }
33098 arg1 = reinterpret_cast< wxWindow * >(argp1);
33099 if (obj1) {
33100 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33101 if (!SWIG_IsOK(ecode2)) {
33102 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
33103 }
33104 arg2 = static_cast< bool >(val2);
33105 }
33106 {
33107 PyThreadState* __tstate = wxPyBeginAllowThreads();
33108 result = (bool)(arg1)->Close(arg2);
33109 wxPyEndAllowThreads(__tstate);
33110 if (PyErr_Occurred()) SWIG_fail;
33111 }
33112 {
33113 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33114 }
33115 return resultobj;
33116 fail:
33117 return NULL;
33118 }
33119
33120
33121 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33122 PyObject *resultobj = 0;
33123 wxWindow *arg1 = (wxWindow *) 0 ;
33124 bool result;
33125 void *argp1 = 0 ;
33126 int res1 = 0 ;
33127 PyObject *swig_obj[1] ;
33128
33129 if (!args) SWIG_fail;
33130 swig_obj[0] = args;
33131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33132 if (!SWIG_IsOK(res1)) {
33133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
33134 }
33135 arg1 = reinterpret_cast< wxWindow * >(argp1);
33136 {
33137 PyThreadState* __tstate = wxPyBeginAllowThreads();
33138 result = (bool)(arg1)->Destroy();
33139 wxPyEndAllowThreads(__tstate);
33140 if (PyErr_Occurred()) SWIG_fail;
33141 }
33142 {
33143 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33144 }
33145 return resultobj;
33146 fail:
33147 return NULL;
33148 }
33149
33150
33151 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33152 PyObject *resultobj = 0;
33153 wxWindow *arg1 = (wxWindow *) 0 ;
33154 bool result;
33155 void *argp1 = 0 ;
33156 int res1 = 0 ;
33157 PyObject *swig_obj[1] ;
33158
33159 if (!args) SWIG_fail;
33160 swig_obj[0] = args;
33161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33162 if (!SWIG_IsOK(res1)) {
33163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
33164 }
33165 arg1 = reinterpret_cast< wxWindow * >(argp1);
33166 {
33167 PyThreadState* __tstate = wxPyBeginAllowThreads();
33168 result = (bool)(arg1)->DestroyChildren();
33169 wxPyEndAllowThreads(__tstate);
33170 if (PyErr_Occurred()) SWIG_fail;
33171 }
33172 {
33173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33174 }
33175 return resultobj;
33176 fail:
33177 return NULL;
33178 }
33179
33180
33181 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33182 PyObject *resultobj = 0;
33183 wxWindow *arg1 = (wxWindow *) 0 ;
33184 bool result;
33185 void *argp1 = 0 ;
33186 int res1 = 0 ;
33187 PyObject *swig_obj[1] ;
33188
33189 if (!args) SWIG_fail;
33190 swig_obj[0] = args;
33191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33192 if (!SWIG_IsOK(res1)) {
33193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
33194 }
33195 arg1 = reinterpret_cast< wxWindow * >(argp1);
33196 {
33197 PyThreadState* __tstate = wxPyBeginAllowThreads();
33198 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
33199 wxPyEndAllowThreads(__tstate);
33200 if (PyErr_Occurred()) SWIG_fail;
33201 }
33202 {
33203 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33204 }
33205 return resultobj;
33206 fail:
33207 return NULL;
33208 }
33209
33210
33211 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33212 PyObject *resultobj = 0;
33213 wxWindow *arg1 = (wxWindow *) 0 ;
33214 wxString *arg2 = 0 ;
33215 void *argp1 = 0 ;
33216 int res1 = 0 ;
33217 bool temp2 = false ;
33218 PyObject * obj0 = 0 ;
33219 PyObject * obj1 = 0 ;
33220 char * kwnames[] = {
33221 (char *) "self",(char *) "label", NULL
33222 };
33223
33224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
33225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33226 if (!SWIG_IsOK(res1)) {
33227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
33228 }
33229 arg1 = reinterpret_cast< wxWindow * >(argp1);
33230 {
33231 arg2 = wxString_in_helper(obj1);
33232 if (arg2 == NULL) SWIG_fail;
33233 temp2 = true;
33234 }
33235 {
33236 PyThreadState* __tstate = wxPyBeginAllowThreads();
33237 (arg1)->SetLabel((wxString const &)*arg2);
33238 wxPyEndAllowThreads(__tstate);
33239 if (PyErr_Occurred()) SWIG_fail;
33240 }
33241 resultobj = SWIG_Py_Void();
33242 {
33243 if (temp2)
33244 delete arg2;
33245 }
33246 return resultobj;
33247 fail:
33248 {
33249 if (temp2)
33250 delete arg2;
33251 }
33252 return NULL;
33253 }
33254
33255
33256 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33257 PyObject *resultobj = 0;
33258 wxWindow *arg1 = (wxWindow *) 0 ;
33259 wxString result;
33260 void *argp1 = 0 ;
33261 int res1 = 0 ;
33262 PyObject *swig_obj[1] ;
33263
33264 if (!args) SWIG_fail;
33265 swig_obj[0] = args;
33266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33267 if (!SWIG_IsOK(res1)) {
33268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33269 }
33270 arg1 = reinterpret_cast< wxWindow * >(argp1);
33271 {
33272 PyThreadState* __tstate = wxPyBeginAllowThreads();
33273 result = ((wxWindow const *)arg1)->GetLabel();
33274 wxPyEndAllowThreads(__tstate);
33275 if (PyErr_Occurred()) SWIG_fail;
33276 }
33277 {
33278 #if wxUSE_UNICODE
33279 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33280 #else
33281 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33282 #endif
33283 }
33284 return resultobj;
33285 fail:
33286 return NULL;
33287 }
33288
33289
33290 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33291 PyObject *resultobj = 0;
33292 wxWindow *arg1 = (wxWindow *) 0 ;
33293 wxString *arg2 = 0 ;
33294 void *argp1 = 0 ;
33295 int res1 = 0 ;
33296 bool temp2 = false ;
33297 PyObject * obj0 = 0 ;
33298 PyObject * obj1 = 0 ;
33299 char * kwnames[] = {
33300 (char *) "self",(char *) "name", NULL
33301 };
33302
33303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
33304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33305 if (!SWIG_IsOK(res1)) {
33306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
33307 }
33308 arg1 = reinterpret_cast< wxWindow * >(argp1);
33309 {
33310 arg2 = wxString_in_helper(obj1);
33311 if (arg2 == NULL) SWIG_fail;
33312 temp2 = true;
33313 }
33314 {
33315 PyThreadState* __tstate = wxPyBeginAllowThreads();
33316 (arg1)->SetName((wxString const &)*arg2);
33317 wxPyEndAllowThreads(__tstate);
33318 if (PyErr_Occurred()) SWIG_fail;
33319 }
33320 resultobj = SWIG_Py_Void();
33321 {
33322 if (temp2)
33323 delete arg2;
33324 }
33325 return resultobj;
33326 fail:
33327 {
33328 if (temp2)
33329 delete arg2;
33330 }
33331 return NULL;
33332 }
33333
33334
33335 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33336 PyObject *resultobj = 0;
33337 wxWindow *arg1 = (wxWindow *) 0 ;
33338 wxString result;
33339 void *argp1 = 0 ;
33340 int res1 = 0 ;
33341 PyObject *swig_obj[1] ;
33342
33343 if (!args) SWIG_fail;
33344 swig_obj[0] = args;
33345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33346 if (!SWIG_IsOK(res1)) {
33347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
33348 }
33349 arg1 = reinterpret_cast< wxWindow * >(argp1);
33350 {
33351 PyThreadState* __tstate = wxPyBeginAllowThreads();
33352 result = ((wxWindow const *)arg1)->GetName();
33353 wxPyEndAllowThreads(__tstate);
33354 if (PyErr_Occurred()) SWIG_fail;
33355 }
33356 {
33357 #if wxUSE_UNICODE
33358 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33359 #else
33360 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33361 #endif
33362 }
33363 return resultobj;
33364 fail:
33365 return NULL;
33366 }
33367
33368
33369 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33370 PyObject *resultobj = 0;
33371 wxWindow *arg1 = (wxWindow *) 0 ;
33372 wxWindowVariant arg2 ;
33373 void *argp1 = 0 ;
33374 int res1 = 0 ;
33375 int val2 ;
33376 int ecode2 = 0 ;
33377 PyObject * obj0 = 0 ;
33378 PyObject * obj1 = 0 ;
33379 char * kwnames[] = {
33380 (char *) "self",(char *) "variant", NULL
33381 };
33382
33383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
33384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33385 if (!SWIG_IsOK(res1)) {
33386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
33387 }
33388 arg1 = reinterpret_cast< wxWindow * >(argp1);
33389 ecode2 = SWIG_AsVal_int(obj1, &val2);
33390 if (!SWIG_IsOK(ecode2)) {
33391 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
33392 }
33393 arg2 = static_cast< wxWindowVariant >(val2);
33394 {
33395 PyThreadState* __tstate = wxPyBeginAllowThreads();
33396 (arg1)->SetWindowVariant(arg2);
33397 wxPyEndAllowThreads(__tstate);
33398 if (PyErr_Occurred()) SWIG_fail;
33399 }
33400 resultobj = SWIG_Py_Void();
33401 return resultobj;
33402 fail:
33403 return NULL;
33404 }
33405
33406
33407 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33408 PyObject *resultobj = 0;
33409 wxWindow *arg1 = (wxWindow *) 0 ;
33410 wxWindowVariant result;
33411 void *argp1 = 0 ;
33412 int res1 = 0 ;
33413 PyObject *swig_obj[1] ;
33414
33415 if (!args) SWIG_fail;
33416 swig_obj[0] = args;
33417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33418 if (!SWIG_IsOK(res1)) {
33419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
33420 }
33421 arg1 = reinterpret_cast< wxWindow * >(argp1);
33422 {
33423 PyThreadState* __tstate = wxPyBeginAllowThreads();
33424 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
33425 wxPyEndAllowThreads(__tstate);
33426 if (PyErr_Occurred()) SWIG_fail;
33427 }
33428 resultobj = SWIG_From_int(static_cast< int >(result));
33429 return resultobj;
33430 fail:
33431 return NULL;
33432 }
33433
33434
33435 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33436 PyObject *resultobj = 0;
33437 wxWindow *arg1 = (wxWindow *) 0 ;
33438 int arg2 ;
33439 void *argp1 = 0 ;
33440 int res1 = 0 ;
33441 int val2 ;
33442 int ecode2 = 0 ;
33443 PyObject * obj0 = 0 ;
33444 PyObject * obj1 = 0 ;
33445 char * kwnames[] = {
33446 (char *) "self",(char *) "winid", NULL
33447 };
33448
33449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
33450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33451 if (!SWIG_IsOK(res1)) {
33452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
33453 }
33454 arg1 = reinterpret_cast< wxWindow * >(argp1);
33455 ecode2 = SWIG_AsVal_int(obj1, &val2);
33456 if (!SWIG_IsOK(ecode2)) {
33457 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
33458 }
33459 arg2 = static_cast< int >(val2);
33460 {
33461 PyThreadState* __tstate = wxPyBeginAllowThreads();
33462 (arg1)->SetId(arg2);
33463 wxPyEndAllowThreads(__tstate);
33464 if (PyErr_Occurred()) SWIG_fail;
33465 }
33466 resultobj = SWIG_Py_Void();
33467 return resultobj;
33468 fail:
33469 return NULL;
33470 }
33471
33472
33473 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33474 PyObject *resultobj = 0;
33475 wxWindow *arg1 = (wxWindow *) 0 ;
33476 int result;
33477 void *argp1 = 0 ;
33478 int res1 = 0 ;
33479 PyObject *swig_obj[1] ;
33480
33481 if (!args) SWIG_fail;
33482 swig_obj[0] = args;
33483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33484 if (!SWIG_IsOK(res1)) {
33485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
33486 }
33487 arg1 = reinterpret_cast< wxWindow * >(argp1);
33488 {
33489 PyThreadState* __tstate = wxPyBeginAllowThreads();
33490 result = (int)((wxWindow const *)arg1)->GetId();
33491 wxPyEndAllowThreads(__tstate);
33492 if (PyErr_Occurred()) SWIG_fail;
33493 }
33494 resultobj = SWIG_From_int(static_cast< int >(result));
33495 return resultobj;
33496 fail:
33497 return NULL;
33498 }
33499
33500
33501 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33502 PyObject *resultobj = 0;
33503 int result;
33504
33505 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
33506 {
33507 PyThreadState* __tstate = wxPyBeginAllowThreads();
33508 result = (int)wxWindow::NewControlId();
33509 wxPyEndAllowThreads(__tstate);
33510 if (PyErr_Occurred()) SWIG_fail;
33511 }
33512 resultobj = SWIG_From_int(static_cast< int >(result));
33513 return resultobj;
33514 fail:
33515 return NULL;
33516 }
33517
33518
33519 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33520 PyObject *resultobj = 0;
33521 int arg1 ;
33522 int result;
33523 int val1 ;
33524 int ecode1 = 0 ;
33525 PyObject * obj0 = 0 ;
33526 char * kwnames[] = {
33527 (char *) "winid", NULL
33528 };
33529
33530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
33531 ecode1 = SWIG_AsVal_int(obj0, &val1);
33532 if (!SWIG_IsOK(ecode1)) {
33533 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
33534 }
33535 arg1 = static_cast< int >(val1);
33536 {
33537 PyThreadState* __tstate = wxPyBeginAllowThreads();
33538 result = (int)wxWindow::NextControlId(arg1);
33539 wxPyEndAllowThreads(__tstate);
33540 if (PyErr_Occurred()) SWIG_fail;
33541 }
33542 resultobj = SWIG_From_int(static_cast< int >(result));
33543 return resultobj;
33544 fail:
33545 return NULL;
33546 }
33547
33548
33549 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33550 PyObject *resultobj = 0;
33551 int arg1 ;
33552 int result;
33553 int val1 ;
33554 int ecode1 = 0 ;
33555 PyObject * obj0 = 0 ;
33556 char * kwnames[] = {
33557 (char *) "winid", NULL
33558 };
33559
33560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
33561 ecode1 = SWIG_AsVal_int(obj0, &val1);
33562 if (!SWIG_IsOK(ecode1)) {
33563 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
33564 }
33565 arg1 = static_cast< int >(val1);
33566 {
33567 PyThreadState* __tstate = wxPyBeginAllowThreads();
33568 result = (int)wxWindow::PrevControlId(arg1);
33569 wxPyEndAllowThreads(__tstate);
33570 if (PyErr_Occurred()) SWIG_fail;
33571 }
33572 resultobj = SWIG_From_int(static_cast< int >(result));
33573 return resultobj;
33574 fail:
33575 return NULL;
33576 }
33577
33578
33579 SWIGINTERN PyObject *_wrap_Window_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33580 PyObject *resultobj = 0;
33581 wxWindow *arg1 = (wxWindow *) 0 ;
33582 wxLayoutDirection result;
33583 void *argp1 = 0 ;
33584 int res1 = 0 ;
33585 PyObject *swig_obj[1] ;
33586
33587 if (!args) SWIG_fail;
33588 swig_obj[0] = args;
33589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33590 if (!SWIG_IsOK(res1)) {
33591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
33592 }
33593 arg1 = reinterpret_cast< wxWindow * >(argp1);
33594 {
33595 PyThreadState* __tstate = wxPyBeginAllowThreads();
33596 result = (wxLayoutDirection)((wxWindow const *)arg1)->GetLayoutDirection();
33597 wxPyEndAllowThreads(__tstate);
33598 if (PyErr_Occurred()) SWIG_fail;
33599 }
33600 resultobj = SWIG_From_int(static_cast< int >(result));
33601 return resultobj;
33602 fail:
33603 return NULL;
33604 }
33605
33606
33607 SWIGINTERN PyObject *_wrap_Window_SetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33608 PyObject *resultobj = 0;
33609 wxWindow *arg1 = (wxWindow *) 0 ;
33610 wxLayoutDirection arg2 ;
33611 void *argp1 = 0 ;
33612 int res1 = 0 ;
33613 int val2 ;
33614 int ecode2 = 0 ;
33615 PyObject * obj0 = 0 ;
33616 PyObject * obj1 = 0 ;
33617 char * kwnames[] = {
33618 (char *) "self",(char *) "dir", NULL
33619 };
33620
33621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLayoutDirection",kwnames,&obj0,&obj1)) SWIG_fail;
33622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33623 if (!SWIG_IsOK(res1)) {
33624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow *""'");
33625 }
33626 arg1 = reinterpret_cast< wxWindow * >(argp1);
33627 ecode2 = SWIG_AsVal_int(obj1, &val2);
33628 if (!SWIG_IsOK(ecode2)) {
33629 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetLayoutDirection" "', expected argument " "2"" of type '" "wxLayoutDirection""'");
33630 }
33631 arg2 = static_cast< wxLayoutDirection >(val2);
33632 {
33633 PyThreadState* __tstate = wxPyBeginAllowThreads();
33634 (arg1)->SetLayoutDirection(arg2);
33635 wxPyEndAllowThreads(__tstate);
33636 if (PyErr_Occurred()) SWIG_fail;
33637 }
33638 resultobj = SWIG_Py_Void();
33639 return resultobj;
33640 fail:
33641 return NULL;
33642 }
33643
33644
33645 SWIGINTERN PyObject *_wrap_Window_AdjustForLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33646 PyObject *resultobj = 0;
33647 wxWindow *arg1 = (wxWindow *) 0 ;
33648 int arg2 ;
33649 int arg3 ;
33650 int arg4 ;
33651 int result;
33652 void *argp1 = 0 ;
33653 int res1 = 0 ;
33654 int val2 ;
33655 int ecode2 = 0 ;
33656 int val3 ;
33657 int ecode3 = 0 ;
33658 int val4 ;
33659 int ecode4 = 0 ;
33660 PyObject * obj0 = 0 ;
33661 PyObject * obj1 = 0 ;
33662 PyObject * obj2 = 0 ;
33663 PyObject * obj3 = 0 ;
33664 char * kwnames[] = {
33665 (char *) "self",(char *) "x",(char *) "width",(char *) "widthTotal", NULL
33666 };
33667
33668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_AdjustForLayoutDirection",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33670 if (!SWIG_IsOK(res1)) {
33671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
33672 }
33673 arg1 = reinterpret_cast< wxWindow * >(argp1);
33674 ecode2 = SWIG_AsVal_int(obj1, &val2);
33675 if (!SWIG_IsOK(ecode2)) {
33676 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "2"" of type '" "int""'");
33677 }
33678 arg2 = static_cast< int >(val2);
33679 ecode3 = SWIG_AsVal_int(obj2, &val3);
33680 if (!SWIG_IsOK(ecode3)) {
33681 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "3"" of type '" "int""'");
33682 }
33683 arg3 = static_cast< int >(val3);
33684 ecode4 = SWIG_AsVal_int(obj3, &val4);
33685 if (!SWIG_IsOK(ecode4)) {
33686 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "4"" of type '" "int""'");
33687 }
33688 arg4 = static_cast< int >(val4);
33689 {
33690 PyThreadState* __tstate = wxPyBeginAllowThreads();
33691 result = (int)((wxWindow const *)arg1)->AdjustForLayoutDirection(arg2,arg3,arg4);
33692 wxPyEndAllowThreads(__tstate);
33693 if (PyErr_Occurred()) SWIG_fail;
33694 }
33695 resultobj = SWIG_From_int(static_cast< int >(result));
33696 return resultobj;
33697 fail:
33698 return NULL;
33699 }
33700
33701
33702 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33703 PyObject *resultobj = 0;
33704 wxWindow *arg1 = (wxWindow *) 0 ;
33705 wxSize *arg2 = 0 ;
33706 void *argp1 = 0 ;
33707 int res1 = 0 ;
33708 wxSize temp2 ;
33709 PyObject * obj0 = 0 ;
33710 PyObject * obj1 = 0 ;
33711 char * kwnames[] = {
33712 (char *) "self",(char *) "size", NULL
33713 };
33714
33715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
33716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33717 if (!SWIG_IsOK(res1)) {
33718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33719 }
33720 arg1 = reinterpret_cast< wxWindow * >(argp1);
33721 {
33722 arg2 = &temp2;
33723 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33724 }
33725 {
33726 PyThreadState* __tstate = wxPyBeginAllowThreads();
33727 (arg1)->SetSize((wxSize const &)*arg2);
33728 wxPyEndAllowThreads(__tstate);
33729 if (PyErr_Occurred()) SWIG_fail;
33730 }
33731 resultobj = SWIG_Py_Void();
33732 return resultobj;
33733 fail:
33734 return NULL;
33735 }
33736
33737
33738 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33739 PyObject *resultobj = 0;
33740 wxWindow *arg1 = (wxWindow *) 0 ;
33741 int arg2 ;
33742 int arg3 ;
33743 int arg4 ;
33744 int arg5 ;
33745 int arg6 = (int) wxSIZE_AUTO ;
33746 void *argp1 = 0 ;
33747 int res1 = 0 ;
33748 int val2 ;
33749 int ecode2 = 0 ;
33750 int val3 ;
33751 int ecode3 = 0 ;
33752 int val4 ;
33753 int ecode4 = 0 ;
33754 int val5 ;
33755 int ecode5 = 0 ;
33756 int val6 ;
33757 int ecode6 = 0 ;
33758 PyObject * obj0 = 0 ;
33759 PyObject * obj1 = 0 ;
33760 PyObject * obj2 = 0 ;
33761 PyObject * obj3 = 0 ;
33762 PyObject * obj4 = 0 ;
33763 PyObject * obj5 = 0 ;
33764 char * kwnames[] = {
33765 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
33766 };
33767
33768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
33769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33770 if (!SWIG_IsOK(res1)) {
33771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
33772 }
33773 arg1 = reinterpret_cast< wxWindow * >(argp1);
33774 ecode2 = SWIG_AsVal_int(obj1, &val2);
33775 if (!SWIG_IsOK(ecode2)) {
33776 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
33777 }
33778 arg2 = static_cast< int >(val2);
33779 ecode3 = SWIG_AsVal_int(obj2, &val3);
33780 if (!SWIG_IsOK(ecode3)) {
33781 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
33782 }
33783 arg3 = static_cast< int >(val3);
33784 ecode4 = SWIG_AsVal_int(obj3, &val4);
33785 if (!SWIG_IsOK(ecode4)) {
33786 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
33787 }
33788 arg4 = static_cast< int >(val4);
33789 ecode5 = SWIG_AsVal_int(obj4, &val5);
33790 if (!SWIG_IsOK(ecode5)) {
33791 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
33792 }
33793 arg5 = static_cast< int >(val5);
33794 if (obj5) {
33795 ecode6 = SWIG_AsVal_int(obj5, &val6);
33796 if (!SWIG_IsOK(ecode6)) {
33797 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
33798 }
33799 arg6 = static_cast< int >(val6);
33800 }
33801 {
33802 PyThreadState* __tstate = wxPyBeginAllowThreads();
33803 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
33804 wxPyEndAllowThreads(__tstate);
33805 if (PyErr_Occurred()) SWIG_fail;
33806 }
33807 resultobj = SWIG_Py_Void();
33808 return resultobj;
33809 fail:
33810 return NULL;
33811 }
33812
33813
33814 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33815 PyObject *resultobj = 0;
33816 wxWindow *arg1 = (wxWindow *) 0 ;
33817 wxRect *arg2 = 0 ;
33818 int arg3 = (int) wxSIZE_AUTO ;
33819 void *argp1 = 0 ;
33820 int res1 = 0 ;
33821 wxRect temp2 ;
33822 int val3 ;
33823 int ecode3 = 0 ;
33824 PyObject * obj0 = 0 ;
33825 PyObject * obj1 = 0 ;
33826 PyObject * obj2 = 0 ;
33827 char * kwnames[] = {
33828 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
33829 };
33830
33831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33833 if (!SWIG_IsOK(res1)) {
33834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
33835 }
33836 arg1 = reinterpret_cast< wxWindow * >(argp1);
33837 {
33838 arg2 = &temp2;
33839 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
33840 }
33841 if (obj2) {
33842 ecode3 = SWIG_AsVal_int(obj2, &val3);
33843 if (!SWIG_IsOK(ecode3)) {
33844 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
33845 }
33846 arg3 = static_cast< int >(val3);
33847 }
33848 {
33849 PyThreadState* __tstate = wxPyBeginAllowThreads();
33850 (arg1)->SetSize((wxRect const &)*arg2,arg3);
33851 wxPyEndAllowThreads(__tstate);
33852 if (PyErr_Occurred()) SWIG_fail;
33853 }
33854 resultobj = SWIG_Py_Void();
33855 return resultobj;
33856 fail:
33857 return NULL;
33858 }
33859
33860
33861 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33862 PyObject *resultobj = 0;
33863 wxWindow *arg1 = (wxWindow *) 0 ;
33864 int arg2 ;
33865 int arg3 ;
33866 void *argp1 = 0 ;
33867 int res1 = 0 ;
33868 int val2 ;
33869 int ecode2 = 0 ;
33870 int val3 ;
33871 int ecode3 = 0 ;
33872 PyObject * obj0 = 0 ;
33873 PyObject * obj1 = 0 ;
33874 PyObject * obj2 = 0 ;
33875 char * kwnames[] = {
33876 (char *) "self",(char *) "width",(char *) "height", NULL
33877 };
33878
33879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33881 if (!SWIG_IsOK(res1)) {
33882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
33883 }
33884 arg1 = reinterpret_cast< wxWindow * >(argp1);
33885 ecode2 = SWIG_AsVal_int(obj1, &val2);
33886 if (!SWIG_IsOK(ecode2)) {
33887 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
33888 }
33889 arg2 = static_cast< int >(val2);
33890 ecode3 = SWIG_AsVal_int(obj2, &val3);
33891 if (!SWIG_IsOK(ecode3)) {
33892 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
33893 }
33894 arg3 = static_cast< int >(val3);
33895 {
33896 PyThreadState* __tstate = wxPyBeginAllowThreads();
33897 (arg1)->SetSize(arg2,arg3);
33898 wxPyEndAllowThreads(__tstate);
33899 if (PyErr_Occurred()) SWIG_fail;
33900 }
33901 resultobj = SWIG_Py_Void();
33902 return resultobj;
33903 fail:
33904 return NULL;
33905 }
33906
33907
33908 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33909 PyObject *resultobj = 0;
33910 wxWindow *arg1 = (wxWindow *) 0 ;
33911 wxPoint *arg2 = 0 ;
33912 int arg3 = (int) wxSIZE_USE_EXISTING ;
33913 void *argp1 = 0 ;
33914 int res1 = 0 ;
33915 wxPoint temp2 ;
33916 int val3 ;
33917 int ecode3 = 0 ;
33918 PyObject * obj0 = 0 ;
33919 PyObject * obj1 = 0 ;
33920 PyObject * obj2 = 0 ;
33921 char * kwnames[] = {
33922 (char *) "self",(char *) "pt",(char *) "flags", NULL
33923 };
33924
33925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33927 if (!SWIG_IsOK(res1)) {
33928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
33929 }
33930 arg1 = reinterpret_cast< wxWindow * >(argp1);
33931 {
33932 arg2 = &temp2;
33933 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33934 }
33935 if (obj2) {
33936 ecode3 = SWIG_AsVal_int(obj2, &val3);
33937 if (!SWIG_IsOK(ecode3)) {
33938 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
33939 }
33940 arg3 = static_cast< int >(val3);
33941 }
33942 {
33943 PyThreadState* __tstate = wxPyBeginAllowThreads();
33944 (arg1)->Move((wxPoint const &)*arg2,arg3);
33945 wxPyEndAllowThreads(__tstate);
33946 if (PyErr_Occurred()) SWIG_fail;
33947 }
33948 resultobj = SWIG_Py_Void();
33949 return resultobj;
33950 fail:
33951 return NULL;
33952 }
33953
33954
33955 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33956 PyObject *resultobj = 0;
33957 wxWindow *arg1 = (wxWindow *) 0 ;
33958 int arg2 ;
33959 int arg3 ;
33960 int arg4 = (int) wxSIZE_USE_EXISTING ;
33961 void *argp1 = 0 ;
33962 int res1 = 0 ;
33963 int val2 ;
33964 int ecode2 = 0 ;
33965 int val3 ;
33966 int ecode3 = 0 ;
33967 int val4 ;
33968 int ecode4 = 0 ;
33969 PyObject * obj0 = 0 ;
33970 PyObject * obj1 = 0 ;
33971 PyObject * obj2 = 0 ;
33972 PyObject * obj3 = 0 ;
33973 char * kwnames[] = {
33974 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
33975 };
33976
33977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33979 if (!SWIG_IsOK(res1)) {
33980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
33981 }
33982 arg1 = reinterpret_cast< wxWindow * >(argp1);
33983 ecode2 = SWIG_AsVal_int(obj1, &val2);
33984 if (!SWIG_IsOK(ecode2)) {
33985 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
33986 }
33987 arg2 = static_cast< int >(val2);
33988 ecode3 = SWIG_AsVal_int(obj2, &val3);
33989 if (!SWIG_IsOK(ecode3)) {
33990 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
33991 }
33992 arg3 = static_cast< int >(val3);
33993 if (obj3) {
33994 ecode4 = SWIG_AsVal_int(obj3, &val4);
33995 if (!SWIG_IsOK(ecode4)) {
33996 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
33997 }
33998 arg4 = static_cast< int >(val4);
33999 }
34000 {
34001 PyThreadState* __tstate = wxPyBeginAllowThreads();
34002 (arg1)->Move(arg2,arg3,arg4);
34003 wxPyEndAllowThreads(__tstate);
34004 if (PyErr_Occurred()) SWIG_fail;
34005 }
34006 resultobj = SWIG_Py_Void();
34007 return resultobj;
34008 fail:
34009 return NULL;
34010 }
34011
34012
34013 SWIGINTERN PyObject *_wrap_Window_SetInitialSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34014 PyObject *resultobj = 0;
34015 wxWindow *arg1 = (wxWindow *) 0 ;
34016 wxSize const &arg2_defvalue = wxDefaultSize ;
34017 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
34018 void *argp1 = 0 ;
34019 int res1 = 0 ;
34020 wxSize temp2 ;
34021 PyObject * obj0 = 0 ;
34022 PyObject * obj1 = 0 ;
34023 char * kwnames[] = {
34024 (char *) "self",(char *) "size", NULL
34025 };
34026
34027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetInitialSize",kwnames,&obj0,&obj1)) SWIG_fail;
34028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34029 if (!SWIG_IsOK(res1)) {
34030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetInitialSize" "', expected argument " "1"" of type '" "wxWindow *""'");
34031 }
34032 arg1 = reinterpret_cast< wxWindow * >(argp1);
34033 if (obj1) {
34034 {
34035 arg2 = &temp2;
34036 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34037 }
34038 }
34039 {
34040 PyThreadState* __tstate = wxPyBeginAllowThreads();
34041 (arg1)->SetInitialSize((wxSize const &)*arg2);
34042 wxPyEndAllowThreads(__tstate);
34043 if (PyErr_Occurred()) SWIG_fail;
34044 }
34045 resultobj = SWIG_Py_Void();
34046 return resultobj;
34047 fail:
34048 return NULL;
34049 }
34050
34051
34052 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34053 PyObject *resultobj = 0;
34054 wxWindow *arg1 = (wxWindow *) 0 ;
34055 void *argp1 = 0 ;
34056 int res1 = 0 ;
34057 PyObject *swig_obj[1] ;
34058
34059 if (!args) SWIG_fail;
34060 swig_obj[0] = args;
34061 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34062 if (!SWIG_IsOK(res1)) {
34063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
34064 }
34065 arg1 = reinterpret_cast< wxWindow * >(argp1);
34066 {
34067 PyThreadState* __tstate = wxPyBeginAllowThreads();
34068 (arg1)->Raise();
34069 wxPyEndAllowThreads(__tstate);
34070 if (PyErr_Occurred()) SWIG_fail;
34071 }
34072 resultobj = SWIG_Py_Void();
34073 return resultobj;
34074 fail:
34075 return NULL;
34076 }
34077
34078
34079 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34080 PyObject *resultobj = 0;
34081 wxWindow *arg1 = (wxWindow *) 0 ;
34082 void *argp1 = 0 ;
34083 int res1 = 0 ;
34084 PyObject *swig_obj[1] ;
34085
34086 if (!args) SWIG_fail;
34087 swig_obj[0] = args;
34088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34089 if (!SWIG_IsOK(res1)) {
34090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
34091 }
34092 arg1 = reinterpret_cast< wxWindow * >(argp1);
34093 {
34094 PyThreadState* __tstate = wxPyBeginAllowThreads();
34095 (arg1)->Lower();
34096 wxPyEndAllowThreads(__tstate);
34097 if (PyErr_Occurred()) SWIG_fail;
34098 }
34099 resultobj = SWIG_Py_Void();
34100 return resultobj;
34101 fail:
34102 return NULL;
34103 }
34104
34105
34106 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34107 PyObject *resultobj = 0;
34108 wxWindow *arg1 = (wxWindow *) 0 ;
34109 wxSize *arg2 = 0 ;
34110 void *argp1 = 0 ;
34111 int res1 = 0 ;
34112 wxSize temp2 ;
34113 PyObject * obj0 = 0 ;
34114 PyObject * obj1 = 0 ;
34115 char * kwnames[] = {
34116 (char *) "self",(char *) "size", NULL
34117 };
34118
34119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
34120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34121 if (!SWIG_IsOK(res1)) {
34122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
34123 }
34124 arg1 = reinterpret_cast< wxWindow * >(argp1);
34125 {
34126 arg2 = &temp2;
34127 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34128 }
34129 {
34130 PyThreadState* __tstate = wxPyBeginAllowThreads();
34131 (arg1)->SetClientSize((wxSize const &)*arg2);
34132 wxPyEndAllowThreads(__tstate);
34133 if (PyErr_Occurred()) SWIG_fail;
34134 }
34135 resultobj = SWIG_Py_Void();
34136 return resultobj;
34137 fail:
34138 return NULL;
34139 }
34140
34141
34142 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34143 PyObject *resultobj = 0;
34144 wxWindow *arg1 = (wxWindow *) 0 ;
34145 int arg2 ;
34146 int arg3 ;
34147 void *argp1 = 0 ;
34148 int res1 = 0 ;
34149 int val2 ;
34150 int ecode2 = 0 ;
34151 int val3 ;
34152 int ecode3 = 0 ;
34153 PyObject * obj0 = 0 ;
34154 PyObject * obj1 = 0 ;
34155 PyObject * obj2 = 0 ;
34156 char * kwnames[] = {
34157 (char *) "self",(char *) "width",(char *) "height", NULL
34158 };
34159
34160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34162 if (!SWIG_IsOK(res1)) {
34163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
34164 }
34165 arg1 = reinterpret_cast< wxWindow * >(argp1);
34166 ecode2 = SWIG_AsVal_int(obj1, &val2);
34167 if (!SWIG_IsOK(ecode2)) {
34168 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
34169 }
34170 arg2 = static_cast< int >(val2);
34171 ecode3 = SWIG_AsVal_int(obj2, &val3);
34172 if (!SWIG_IsOK(ecode3)) {
34173 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
34174 }
34175 arg3 = static_cast< int >(val3);
34176 {
34177 PyThreadState* __tstate = wxPyBeginAllowThreads();
34178 (arg1)->SetClientSize(arg2,arg3);
34179 wxPyEndAllowThreads(__tstate);
34180 if (PyErr_Occurred()) SWIG_fail;
34181 }
34182 resultobj = SWIG_Py_Void();
34183 return resultobj;
34184 fail:
34185 return NULL;
34186 }
34187
34188
34189 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34190 PyObject *resultobj = 0;
34191 wxWindow *arg1 = (wxWindow *) 0 ;
34192 wxRect *arg2 = 0 ;
34193 void *argp1 = 0 ;
34194 int res1 = 0 ;
34195 wxRect temp2 ;
34196 PyObject * obj0 = 0 ;
34197 PyObject * obj1 = 0 ;
34198 char * kwnames[] = {
34199 (char *) "self",(char *) "rect", NULL
34200 };
34201
34202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
34203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34204 if (!SWIG_IsOK(res1)) {
34205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34206 }
34207 arg1 = reinterpret_cast< wxWindow * >(argp1);
34208 {
34209 arg2 = &temp2;
34210 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34211 }
34212 {
34213 PyThreadState* __tstate = wxPyBeginAllowThreads();
34214 (arg1)->SetClientSize((wxRect const &)*arg2);
34215 wxPyEndAllowThreads(__tstate);
34216 if (PyErr_Occurred()) SWIG_fail;
34217 }
34218 resultobj = SWIG_Py_Void();
34219 return resultobj;
34220 fail:
34221 return NULL;
34222 }
34223
34224
34225 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34226 PyObject *resultobj = 0;
34227 wxWindow *arg1 = (wxWindow *) 0 ;
34228 wxPoint result;
34229 void *argp1 = 0 ;
34230 int res1 = 0 ;
34231 PyObject *swig_obj[1] ;
34232
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_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34238 }
34239 arg1 = reinterpret_cast< wxWindow * >(argp1);
34240 {
34241 PyThreadState* __tstate = wxPyBeginAllowThreads();
34242 result = ((wxWindow const *)arg1)->GetPosition();
34243 wxPyEndAllowThreads(__tstate);
34244 if (PyErr_Occurred()) SWIG_fail;
34245 }
34246 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34247 return resultobj;
34248 fail:
34249 return NULL;
34250 }
34251
34252
34253 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34254 PyObject *resultobj = 0;
34255 wxWindow *arg1 = (wxWindow *) 0 ;
34256 int *arg2 = (int *) 0 ;
34257 int *arg3 = (int *) 0 ;
34258 void *argp1 = 0 ;
34259 int res1 = 0 ;
34260 int temp2 ;
34261 int res2 = SWIG_TMPOBJ ;
34262 int temp3 ;
34263 int res3 = SWIG_TMPOBJ ;
34264 PyObject *swig_obj[1] ;
34265
34266 arg2 = &temp2;
34267 arg3 = &temp3;
34268 if (!args) SWIG_fail;
34269 swig_obj[0] = args;
34270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34271 if (!SWIG_IsOK(res1)) {
34272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34273 }
34274 arg1 = reinterpret_cast< wxWindow * >(argp1);
34275 {
34276 PyThreadState* __tstate = wxPyBeginAllowThreads();
34277 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
34278 wxPyEndAllowThreads(__tstate);
34279 if (PyErr_Occurred()) SWIG_fail;
34280 }
34281 resultobj = SWIG_Py_Void();
34282 if (SWIG_IsTmpObj(res2)) {
34283 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34284 } else {
34285 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34286 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34287 }
34288 if (SWIG_IsTmpObj(res3)) {
34289 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34290 } else {
34291 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34292 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34293 }
34294 return resultobj;
34295 fail:
34296 return NULL;
34297 }
34298
34299
34300 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34301 PyObject *resultobj = 0;
34302 wxWindow *arg1 = (wxWindow *) 0 ;
34303 wxPoint result;
34304 void *argp1 = 0 ;
34305 int res1 = 0 ;
34306 PyObject *swig_obj[1] ;
34307
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_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34313 }
34314 arg1 = reinterpret_cast< wxWindow * >(argp1);
34315 {
34316 PyThreadState* __tstate = wxPyBeginAllowThreads();
34317 result = ((wxWindow const *)arg1)->GetScreenPosition();
34318 wxPyEndAllowThreads(__tstate);
34319 if (PyErr_Occurred()) SWIG_fail;
34320 }
34321 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34322 return resultobj;
34323 fail:
34324 return NULL;
34325 }
34326
34327
34328 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34329 PyObject *resultobj = 0;
34330 wxWindow *arg1 = (wxWindow *) 0 ;
34331 int *arg2 = (int *) 0 ;
34332 int *arg3 = (int *) 0 ;
34333 void *argp1 = 0 ;
34334 int res1 = 0 ;
34335 int temp2 ;
34336 int res2 = SWIG_TMPOBJ ;
34337 int temp3 ;
34338 int res3 = SWIG_TMPOBJ ;
34339 PyObject *swig_obj[1] ;
34340
34341 arg2 = &temp2;
34342 arg3 = &temp3;
34343 if (!args) SWIG_fail;
34344 swig_obj[0] = args;
34345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34346 if (!SWIG_IsOK(res1)) {
34347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34348 }
34349 arg1 = reinterpret_cast< wxWindow * >(argp1);
34350 {
34351 PyThreadState* __tstate = wxPyBeginAllowThreads();
34352 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
34353 wxPyEndAllowThreads(__tstate);
34354 if (PyErr_Occurred()) SWIG_fail;
34355 }
34356 resultobj = SWIG_Py_Void();
34357 if (SWIG_IsTmpObj(res2)) {
34358 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34359 } else {
34360 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34361 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34362 }
34363 if (SWIG_IsTmpObj(res3)) {
34364 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34365 } else {
34366 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34367 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34368 }
34369 return resultobj;
34370 fail:
34371 return NULL;
34372 }
34373
34374
34375 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34376 PyObject *resultobj = 0;
34377 wxWindow *arg1 = (wxWindow *) 0 ;
34378 wxRect result;
34379 void *argp1 = 0 ;
34380 int res1 = 0 ;
34381 PyObject *swig_obj[1] ;
34382
34383 if (!args) SWIG_fail;
34384 swig_obj[0] = args;
34385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34386 if (!SWIG_IsOK(res1)) {
34387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34388 }
34389 arg1 = reinterpret_cast< wxWindow * >(argp1);
34390 {
34391 PyThreadState* __tstate = wxPyBeginAllowThreads();
34392 result = ((wxWindow const *)arg1)->GetScreenRect();
34393 wxPyEndAllowThreads(__tstate);
34394 if (PyErr_Occurred()) SWIG_fail;
34395 }
34396 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34397 return resultobj;
34398 fail:
34399 return NULL;
34400 }
34401
34402
34403 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34404 PyObject *resultobj = 0;
34405 wxWindow *arg1 = (wxWindow *) 0 ;
34406 wxSize result;
34407 void *argp1 = 0 ;
34408 int res1 = 0 ;
34409 PyObject *swig_obj[1] ;
34410
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_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34416 }
34417 arg1 = reinterpret_cast< wxWindow * >(argp1);
34418 {
34419 PyThreadState* __tstate = wxPyBeginAllowThreads();
34420 result = ((wxWindow const *)arg1)->GetSize();
34421 wxPyEndAllowThreads(__tstate);
34422 if (PyErr_Occurred()) SWIG_fail;
34423 }
34424 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34425 return resultobj;
34426 fail:
34427 return NULL;
34428 }
34429
34430
34431 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34432 PyObject *resultobj = 0;
34433 wxWindow *arg1 = (wxWindow *) 0 ;
34434 int *arg2 = (int *) 0 ;
34435 int *arg3 = (int *) 0 ;
34436 void *argp1 = 0 ;
34437 int res1 = 0 ;
34438 int temp2 ;
34439 int res2 = SWIG_TMPOBJ ;
34440 int temp3 ;
34441 int res3 = SWIG_TMPOBJ ;
34442 PyObject *swig_obj[1] ;
34443
34444 arg2 = &temp2;
34445 arg3 = &temp3;
34446 if (!args) SWIG_fail;
34447 swig_obj[0] = args;
34448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34449 if (!SWIG_IsOK(res1)) {
34450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34451 }
34452 arg1 = reinterpret_cast< wxWindow * >(argp1);
34453 {
34454 PyThreadState* __tstate = wxPyBeginAllowThreads();
34455 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
34456 wxPyEndAllowThreads(__tstate);
34457 if (PyErr_Occurred()) SWIG_fail;
34458 }
34459 resultobj = SWIG_Py_Void();
34460 if (SWIG_IsTmpObj(res2)) {
34461 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34462 } else {
34463 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34464 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34465 }
34466 if (SWIG_IsTmpObj(res3)) {
34467 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34468 } else {
34469 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34470 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34471 }
34472 return resultobj;
34473 fail:
34474 return NULL;
34475 }
34476
34477
34478 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34479 PyObject *resultobj = 0;
34480 wxWindow *arg1 = (wxWindow *) 0 ;
34481 wxRect result;
34482 void *argp1 = 0 ;
34483 int res1 = 0 ;
34484 PyObject *swig_obj[1] ;
34485
34486 if (!args) SWIG_fail;
34487 swig_obj[0] = args;
34488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34489 if (!SWIG_IsOK(res1)) {
34490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34491 }
34492 arg1 = reinterpret_cast< wxWindow * >(argp1);
34493 {
34494 PyThreadState* __tstate = wxPyBeginAllowThreads();
34495 result = ((wxWindow const *)arg1)->GetRect();
34496 wxPyEndAllowThreads(__tstate);
34497 if (PyErr_Occurred()) SWIG_fail;
34498 }
34499 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34500 return resultobj;
34501 fail:
34502 return NULL;
34503 }
34504
34505
34506 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34507 PyObject *resultobj = 0;
34508 wxWindow *arg1 = (wxWindow *) 0 ;
34509 wxSize result;
34510 void *argp1 = 0 ;
34511 int res1 = 0 ;
34512 PyObject *swig_obj[1] ;
34513
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_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34519 }
34520 arg1 = reinterpret_cast< wxWindow * >(argp1);
34521 {
34522 PyThreadState* __tstate = wxPyBeginAllowThreads();
34523 result = ((wxWindow const *)arg1)->GetClientSize();
34524 wxPyEndAllowThreads(__tstate);
34525 if (PyErr_Occurred()) SWIG_fail;
34526 }
34527 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34528 return resultobj;
34529 fail:
34530 return NULL;
34531 }
34532
34533
34534 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34535 PyObject *resultobj = 0;
34536 wxWindow *arg1 = (wxWindow *) 0 ;
34537 int *arg2 = (int *) 0 ;
34538 int *arg3 = (int *) 0 ;
34539 void *argp1 = 0 ;
34540 int res1 = 0 ;
34541 int temp2 ;
34542 int res2 = SWIG_TMPOBJ ;
34543 int temp3 ;
34544 int res3 = SWIG_TMPOBJ ;
34545 PyObject *swig_obj[1] ;
34546
34547 arg2 = &temp2;
34548 arg3 = &temp3;
34549 if (!args) SWIG_fail;
34550 swig_obj[0] = args;
34551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34552 if (!SWIG_IsOK(res1)) {
34553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34554 }
34555 arg1 = reinterpret_cast< wxWindow * >(argp1);
34556 {
34557 PyThreadState* __tstate = wxPyBeginAllowThreads();
34558 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
34559 wxPyEndAllowThreads(__tstate);
34560 if (PyErr_Occurred()) SWIG_fail;
34561 }
34562 resultobj = SWIG_Py_Void();
34563 if (SWIG_IsTmpObj(res2)) {
34564 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34565 } else {
34566 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34567 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34568 }
34569 if (SWIG_IsTmpObj(res3)) {
34570 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34571 } else {
34572 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34573 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34574 }
34575 return resultobj;
34576 fail:
34577 return NULL;
34578 }
34579
34580
34581 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34582 PyObject *resultobj = 0;
34583 wxWindow *arg1 = (wxWindow *) 0 ;
34584 wxPoint result;
34585 void *argp1 = 0 ;
34586 int res1 = 0 ;
34587 PyObject *swig_obj[1] ;
34588
34589 if (!args) SWIG_fail;
34590 swig_obj[0] = args;
34591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34592 if (!SWIG_IsOK(res1)) {
34593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
34594 }
34595 arg1 = reinterpret_cast< wxWindow * >(argp1);
34596 {
34597 PyThreadState* __tstate = wxPyBeginAllowThreads();
34598 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
34599 wxPyEndAllowThreads(__tstate);
34600 if (PyErr_Occurred()) SWIG_fail;
34601 }
34602 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34603 return resultobj;
34604 fail:
34605 return NULL;
34606 }
34607
34608
34609 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34610 PyObject *resultobj = 0;
34611 wxWindow *arg1 = (wxWindow *) 0 ;
34612 wxRect result;
34613 void *argp1 = 0 ;
34614 int res1 = 0 ;
34615 PyObject *swig_obj[1] ;
34616
34617 if (!args) SWIG_fail;
34618 swig_obj[0] = args;
34619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34620 if (!SWIG_IsOK(res1)) {
34621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34622 }
34623 arg1 = reinterpret_cast< wxWindow * >(argp1);
34624 {
34625 PyThreadState* __tstate = wxPyBeginAllowThreads();
34626 result = ((wxWindow const *)arg1)->GetClientRect();
34627 wxPyEndAllowThreads(__tstate);
34628 if (PyErr_Occurred()) SWIG_fail;
34629 }
34630 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34631 return resultobj;
34632 fail:
34633 return NULL;
34634 }
34635
34636
34637 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34638 PyObject *resultobj = 0;
34639 wxWindow *arg1 = (wxWindow *) 0 ;
34640 wxSize result;
34641 void *argp1 = 0 ;
34642 int res1 = 0 ;
34643 PyObject *swig_obj[1] ;
34644
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_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34650 }
34651 arg1 = reinterpret_cast< wxWindow * >(argp1);
34652 {
34653 PyThreadState* __tstate = wxPyBeginAllowThreads();
34654 result = ((wxWindow const *)arg1)->GetBestSize();
34655 wxPyEndAllowThreads(__tstate);
34656 if (PyErr_Occurred()) SWIG_fail;
34657 }
34658 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34659 return resultobj;
34660 fail:
34661 return NULL;
34662 }
34663
34664
34665 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34666 PyObject *resultobj = 0;
34667 wxWindow *arg1 = (wxWindow *) 0 ;
34668 int *arg2 = (int *) 0 ;
34669 int *arg3 = (int *) 0 ;
34670 void *argp1 = 0 ;
34671 int res1 = 0 ;
34672 int temp2 ;
34673 int res2 = SWIG_TMPOBJ ;
34674 int temp3 ;
34675 int res3 = SWIG_TMPOBJ ;
34676 PyObject *swig_obj[1] ;
34677
34678 arg2 = &temp2;
34679 arg3 = &temp3;
34680 if (!args) SWIG_fail;
34681 swig_obj[0] = args;
34682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34683 if (!SWIG_IsOK(res1)) {
34684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34685 }
34686 arg1 = reinterpret_cast< wxWindow * >(argp1);
34687 {
34688 PyThreadState* __tstate = wxPyBeginAllowThreads();
34689 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
34690 wxPyEndAllowThreads(__tstate);
34691 if (PyErr_Occurred()) SWIG_fail;
34692 }
34693 resultobj = SWIG_Py_Void();
34694 if (SWIG_IsTmpObj(res2)) {
34695 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34696 } else {
34697 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34698 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34699 }
34700 if (SWIG_IsTmpObj(res3)) {
34701 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34702 } else {
34703 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34704 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34705 }
34706 return resultobj;
34707 fail:
34708 return NULL;
34709 }
34710
34711
34712 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34713 PyObject *resultobj = 0;
34714 wxWindow *arg1 = (wxWindow *) 0 ;
34715 void *argp1 = 0 ;
34716 int res1 = 0 ;
34717 PyObject *swig_obj[1] ;
34718
34719 if (!args) SWIG_fail;
34720 swig_obj[0] = args;
34721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34722 if (!SWIG_IsOK(res1)) {
34723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
34724 }
34725 arg1 = reinterpret_cast< wxWindow * >(argp1);
34726 {
34727 PyThreadState* __tstate = wxPyBeginAllowThreads();
34728 (arg1)->InvalidateBestSize();
34729 wxPyEndAllowThreads(__tstate);
34730 if (PyErr_Occurred()) SWIG_fail;
34731 }
34732 resultobj = SWIG_Py_Void();
34733 return resultobj;
34734 fail:
34735 return NULL;
34736 }
34737
34738
34739 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34740 PyObject *resultobj = 0;
34741 wxWindow *arg1 = (wxWindow *) 0 ;
34742 wxSize *arg2 = 0 ;
34743 void *argp1 = 0 ;
34744 int res1 = 0 ;
34745 wxSize temp2 ;
34746 PyObject * obj0 = 0 ;
34747 PyObject * obj1 = 0 ;
34748 char * kwnames[] = {
34749 (char *) "self",(char *) "size", NULL
34750 };
34751
34752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
34753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34754 if (!SWIG_IsOK(res1)) {
34755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34756 }
34757 arg1 = reinterpret_cast< wxWindow * >(argp1);
34758 {
34759 arg2 = &temp2;
34760 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34761 }
34762 {
34763 PyThreadState* __tstate = wxPyBeginAllowThreads();
34764 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
34765 wxPyEndAllowThreads(__tstate);
34766 if (PyErr_Occurred()) SWIG_fail;
34767 }
34768 resultobj = SWIG_Py_Void();
34769 return resultobj;
34770 fail:
34771 return NULL;
34772 }
34773
34774
34775 SWIGINTERN PyObject *_wrap_Window_GetEffectiveMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34776 PyObject *resultobj = 0;
34777 wxWindow *arg1 = (wxWindow *) 0 ;
34778 wxSize result;
34779 void *argp1 = 0 ;
34780 int res1 = 0 ;
34781 PyObject *swig_obj[1] ;
34782
34783 if (!args) SWIG_fail;
34784 swig_obj[0] = args;
34785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34786 if (!SWIG_IsOK(res1)) {
34787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEffectiveMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34788 }
34789 arg1 = reinterpret_cast< wxWindow * >(argp1);
34790 {
34791 PyThreadState* __tstate = wxPyBeginAllowThreads();
34792 result = ((wxWindow const *)arg1)->GetEffectiveMinSize();
34793 wxPyEndAllowThreads(__tstate);
34794 if (PyErr_Occurred()) SWIG_fail;
34795 }
34796 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34797 return resultobj;
34798 fail:
34799 return NULL;
34800 }
34801
34802
34803 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34804 PyObject *resultobj = 0;
34805 wxWindow *arg1 = (wxWindow *) 0 ;
34806 int arg2 = (int) wxBOTH ;
34807 void *argp1 = 0 ;
34808 int res1 = 0 ;
34809 int val2 ;
34810 int ecode2 = 0 ;
34811 PyObject * obj0 = 0 ;
34812 PyObject * obj1 = 0 ;
34813 char * kwnames[] = {
34814 (char *) "self",(char *) "direction", NULL
34815 };
34816
34817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
34818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34819 if (!SWIG_IsOK(res1)) {
34820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
34821 }
34822 arg1 = reinterpret_cast< wxWindow * >(argp1);
34823 if (obj1) {
34824 ecode2 = SWIG_AsVal_int(obj1, &val2);
34825 if (!SWIG_IsOK(ecode2)) {
34826 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
34827 }
34828 arg2 = static_cast< int >(val2);
34829 }
34830 {
34831 PyThreadState* __tstate = wxPyBeginAllowThreads();
34832 (arg1)->Center(arg2);
34833 wxPyEndAllowThreads(__tstate);
34834 if (PyErr_Occurred()) SWIG_fail;
34835 }
34836 resultobj = SWIG_Py_Void();
34837 return resultobj;
34838 fail:
34839 return NULL;
34840 }
34841
34842
34843 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34844 PyObject *resultobj = 0;
34845 wxWindow *arg1 = (wxWindow *) 0 ;
34846 int arg2 = (int) wxBOTH ;
34847 void *argp1 = 0 ;
34848 int res1 = 0 ;
34849 int val2 ;
34850 int ecode2 = 0 ;
34851 PyObject * obj0 = 0 ;
34852 PyObject * obj1 = 0 ;
34853 char * kwnames[] = {
34854 (char *) "self",(char *) "dir", NULL
34855 };
34856
34857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
34858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34859 if (!SWIG_IsOK(res1)) {
34860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
34861 }
34862 arg1 = reinterpret_cast< wxWindow * >(argp1);
34863 if (obj1) {
34864 ecode2 = SWIG_AsVal_int(obj1, &val2);
34865 if (!SWIG_IsOK(ecode2)) {
34866 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
34867 }
34868 arg2 = static_cast< int >(val2);
34869 }
34870 {
34871 PyThreadState* __tstate = wxPyBeginAllowThreads();
34872 (arg1)->CenterOnParent(arg2);
34873 wxPyEndAllowThreads(__tstate);
34874 if (PyErr_Occurred()) SWIG_fail;
34875 }
34876 resultobj = SWIG_Py_Void();
34877 return resultobj;
34878 fail:
34879 return NULL;
34880 }
34881
34882
34883 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34884 PyObject *resultobj = 0;
34885 wxWindow *arg1 = (wxWindow *) 0 ;
34886 void *argp1 = 0 ;
34887 int res1 = 0 ;
34888 PyObject *swig_obj[1] ;
34889
34890 if (!args) SWIG_fail;
34891 swig_obj[0] = args;
34892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34893 if (!SWIG_IsOK(res1)) {
34894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
34895 }
34896 arg1 = reinterpret_cast< wxWindow * >(argp1);
34897 {
34898 PyThreadState* __tstate = wxPyBeginAllowThreads();
34899 (arg1)->Fit();
34900 wxPyEndAllowThreads(__tstate);
34901 if (PyErr_Occurred()) SWIG_fail;
34902 }
34903 resultobj = SWIG_Py_Void();
34904 return resultobj;
34905 fail:
34906 return NULL;
34907 }
34908
34909
34910 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34911 PyObject *resultobj = 0;
34912 wxWindow *arg1 = (wxWindow *) 0 ;
34913 void *argp1 = 0 ;
34914 int res1 = 0 ;
34915 PyObject *swig_obj[1] ;
34916
34917 if (!args) SWIG_fail;
34918 swig_obj[0] = args;
34919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34920 if (!SWIG_IsOK(res1)) {
34921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
34922 }
34923 arg1 = reinterpret_cast< wxWindow * >(argp1);
34924 {
34925 PyThreadState* __tstate = wxPyBeginAllowThreads();
34926 (arg1)->FitInside();
34927 wxPyEndAllowThreads(__tstate);
34928 if (PyErr_Occurred()) SWIG_fail;
34929 }
34930 resultobj = SWIG_Py_Void();
34931 return resultobj;
34932 fail:
34933 return NULL;
34934 }
34935
34936
34937 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34938 PyObject *resultobj = 0;
34939 wxWindow *arg1 = (wxWindow *) 0 ;
34940 int arg2 ;
34941 int arg3 ;
34942 int arg4 = (int) -1 ;
34943 int arg5 = (int) -1 ;
34944 int arg6 = (int) -1 ;
34945 int arg7 = (int) -1 ;
34946 void *argp1 = 0 ;
34947 int res1 = 0 ;
34948 int val2 ;
34949 int ecode2 = 0 ;
34950 int val3 ;
34951 int ecode3 = 0 ;
34952 int val4 ;
34953 int ecode4 = 0 ;
34954 int val5 ;
34955 int ecode5 = 0 ;
34956 int val6 ;
34957 int ecode6 = 0 ;
34958 int val7 ;
34959 int ecode7 = 0 ;
34960 PyObject * obj0 = 0 ;
34961 PyObject * obj1 = 0 ;
34962 PyObject * obj2 = 0 ;
34963 PyObject * obj3 = 0 ;
34964 PyObject * obj4 = 0 ;
34965 PyObject * obj5 = 0 ;
34966 PyObject * obj6 = 0 ;
34967 char * kwnames[] = {
34968 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
34969 };
34970
34971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
34972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34973 if (!SWIG_IsOK(res1)) {
34974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
34975 }
34976 arg1 = reinterpret_cast< wxWindow * >(argp1);
34977 ecode2 = SWIG_AsVal_int(obj1, &val2);
34978 if (!SWIG_IsOK(ecode2)) {
34979 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
34980 }
34981 arg2 = static_cast< int >(val2);
34982 ecode3 = SWIG_AsVal_int(obj2, &val3);
34983 if (!SWIG_IsOK(ecode3)) {
34984 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
34985 }
34986 arg3 = static_cast< int >(val3);
34987 if (obj3) {
34988 ecode4 = SWIG_AsVal_int(obj3, &val4);
34989 if (!SWIG_IsOK(ecode4)) {
34990 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
34991 }
34992 arg4 = static_cast< int >(val4);
34993 }
34994 if (obj4) {
34995 ecode5 = SWIG_AsVal_int(obj4, &val5);
34996 if (!SWIG_IsOK(ecode5)) {
34997 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
34998 }
34999 arg5 = static_cast< int >(val5);
35000 }
35001 if (obj5) {
35002 ecode6 = SWIG_AsVal_int(obj5, &val6);
35003 if (!SWIG_IsOK(ecode6)) {
35004 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
35005 }
35006 arg6 = static_cast< int >(val6);
35007 }
35008 if (obj6) {
35009 ecode7 = SWIG_AsVal_int(obj6, &val7);
35010 if (!SWIG_IsOK(ecode7)) {
35011 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
35012 }
35013 arg7 = static_cast< int >(val7);
35014 }
35015 {
35016 PyThreadState* __tstate = wxPyBeginAllowThreads();
35017 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
35018 wxPyEndAllowThreads(__tstate);
35019 if (PyErr_Occurred()) SWIG_fail;
35020 }
35021 resultobj = SWIG_Py_Void();
35022 return resultobj;
35023 fail:
35024 return NULL;
35025 }
35026
35027
35028 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35029 PyObject *resultobj = 0;
35030 wxWindow *arg1 = (wxWindow *) 0 ;
35031 wxSize *arg2 = 0 ;
35032 wxSize const &arg3_defvalue = wxDefaultSize ;
35033 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
35034 wxSize const &arg4_defvalue = wxDefaultSize ;
35035 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
35036 void *argp1 = 0 ;
35037 int res1 = 0 ;
35038 wxSize temp2 ;
35039 wxSize temp3 ;
35040 wxSize temp4 ;
35041 PyObject * obj0 = 0 ;
35042 PyObject * obj1 = 0 ;
35043 PyObject * obj2 = 0 ;
35044 PyObject * obj3 = 0 ;
35045 char * kwnames[] = {
35046 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
35047 };
35048
35049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35051 if (!SWIG_IsOK(res1)) {
35052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
35053 }
35054 arg1 = reinterpret_cast< wxWindow * >(argp1);
35055 {
35056 arg2 = &temp2;
35057 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35058 }
35059 if (obj2) {
35060 {
35061 arg3 = &temp3;
35062 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
35063 }
35064 }
35065 if (obj3) {
35066 {
35067 arg4 = &temp4;
35068 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
35069 }
35070 }
35071 {
35072 PyThreadState* __tstate = wxPyBeginAllowThreads();
35073 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
35074 wxPyEndAllowThreads(__tstate);
35075 if (PyErr_Occurred()) SWIG_fail;
35076 }
35077 resultobj = SWIG_Py_Void();
35078 return resultobj;
35079 fail:
35080 return NULL;
35081 }
35082
35083
35084 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35085 PyObject *resultobj = 0;
35086 wxWindow *arg1 = (wxWindow *) 0 ;
35087 int arg2 ;
35088 int arg3 ;
35089 int arg4 = (int) -1 ;
35090 int arg5 = (int) -1 ;
35091 void *argp1 = 0 ;
35092 int res1 = 0 ;
35093 int val2 ;
35094 int ecode2 = 0 ;
35095 int val3 ;
35096 int ecode3 = 0 ;
35097 int val4 ;
35098 int ecode4 = 0 ;
35099 int val5 ;
35100 int ecode5 = 0 ;
35101 PyObject * obj0 = 0 ;
35102 PyObject * obj1 = 0 ;
35103 PyObject * obj2 = 0 ;
35104 PyObject * obj3 = 0 ;
35105 PyObject * obj4 = 0 ;
35106 char * kwnames[] = {
35107 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
35108 };
35109
35110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
35111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35112 if (!SWIG_IsOK(res1)) {
35113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
35114 }
35115 arg1 = reinterpret_cast< wxWindow * >(argp1);
35116 ecode2 = SWIG_AsVal_int(obj1, &val2);
35117 if (!SWIG_IsOK(ecode2)) {
35118 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
35119 }
35120 arg2 = static_cast< int >(val2);
35121 ecode3 = SWIG_AsVal_int(obj2, &val3);
35122 if (!SWIG_IsOK(ecode3)) {
35123 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
35124 }
35125 arg3 = static_cast< int >(val3);
35126 if (obj3) {
35127 ecode4 = SWIG_AsVal_int(obj3, &val4);
35128 if (!SWIG_IsOK(ecode4)) {
35129 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
35130 }
35131 arg4 = static_cast< int >(val4);
35132 }
35133 if (obj4) {
35134 ecode5 = SWIG_AsVal_int(obj4, &val5);
35135 if (!SWIG_IsOK(ecode5)) {
35136 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
35137 }
35138 arg5 = static_cast< int >(val5);
35139 }
35140 {
35141 PyThreadState* __tstate = wxPyBeginAllowThreads();
35142 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
35143 wxPyEndAllowThreads(__tstate);
35144 if (PyErr_Occurred()) SWIG_fail;
35145 }
35146 resultobj = SWIG_Py_Void();
35147 return resultobj;
35148 fail:
35149 return NULL;
35150 }
35151
35152
35153 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35154 PyObject *resultobj = 0;
35155 wxWindow *arg1 = (wxWindow *) 0 ;
35156 wxSize *arg2 = 0 ;
35157 wxSize const &arg3_defvalue = wxDefaultSize ;
35158 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
35159 void *argp1 = 0 ;
35160 int res1 = 0 ;
35161 wxSize temp2 ;
35162 wxSize temp3 ;
35163 PyObject * obj0 = 0 ;
35164 PyObject * obj1 = 0 ;
35165 PyObject * obj2 = 0 ;
35166 char * kwnames[] = {
35167 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
35168 };
35169
35170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35172 if (!SWIG_IsOK(res1)) {
35173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
35174 }
35175 arg1 = reinterpret_cast< wxWindow * >(argp1);
35176 {
35177 arg2 = &temp2;
35178 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35179 }
35180 if (obj2) {
35181 {
35182 arg3 = &temp3;
35183 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
35184 }
35185 }
35186 {
35187 PyThreadState* __tstate = wxPyBeginAllowThreads();
35188 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
35189 wxPyEndAllowThreads(__tstate);
35190 if (PyErr_Occurred()) SWIG_fail;
35191 }
35192 resultobj = SWIG_Py_Void();
35193 return resultobj;
35194 fail:
35195 return NULL;
35196 }
35197
35198
35199 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35200 PyObject *resultobj = 0;
35201 wxWindow *arg1 = (wxWindow *) 0 ;
35202 wxSize result;
35203 void *argp1 = 0 ;
35204 int res1 = 0 ;
35205 PyObject *swig_obj[1] ;
35206
35207 if (!args) SWIG_fail;
35208 swig_obj[0] = args;
35209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35210 if (!SWIG_IsOK(res1)) {
35211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35212 }
35213 arg1 = reinterpret_cast< wxWindow * >(argp1);
35214 {
35215 PyThreadState* __tstate = wxPyBeginAllowThreads();
35216 result = ((wxWindow const *)arg1)->GetMaxSize();
35217 wxPyEndAllowThreads(__tstate);
35218 if (PyErr_Occurred()) SWIG_fail;
35219 }
35220 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35221 return resultobj;
35222 fail:
35223 return NULL;
35224 }
35225
35226
35227 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35228 PyObject *resultobj = 0;
35229 wxWindow *arg1 = (wxWindow *) 0 ;
35230 wxSize result;
35231 void *argp1 = 0 ;
35232 int res1 = 0 ;
35233 PyObject *swig_obj[1] ;
35234
35235 if (!args) SWIG_fail;
35236 swig_obj[0] = args;
35237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35238 if (!SWIG_IsOK(res1)) {
35239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35240 }
35241 arg1 = reinterpret_cast< wxWindow * >(argp1);
35242 {
35243 PyThreadState* __tstate = wxPyBeginAllowThreads();
35244 result = ((wxWindow const *)arg1)->GetMinSize();
35245 wxPyEndAllowThreads(__tstate);
35246 if (PyErr_Occurred()) SWIG_fail;
35247 }
35248 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35249 return resultobj;
35250 fail:
35251 return NULL;
35252 }
35253
35254
35255 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35256 PyObject *resultobj = 0;
35257 wxWindow *arg1 = (wxWindow *) 0 ;
35258 wxSize *arg2 = 0 ;
35259 void *argp1 = 0 ;
35260 int res1 = 0 ;
35261 wxSize temp2 ;
35262 PyObject * obj0 = 0 ;
35263 PyObject * obj1 = 0 ;
35264 char * kwnames[] = {
35265 (char *) "self",(char *) "minSize", NULL
35266 };
35267
35268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
35269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35270 if (!SWIG_IsOK(res1)) {
35271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35272 }
35273 arg1 = reinterpret_cast< wxWindow * >(argp1);
35274 {
35275 arg2 = &temp2;
35276 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35277 }
35278 {
35279 PyThreadState* __tstate = wxPyBeginAllowThreads();
35280 (arg1)->SetMinSize((wxSize const &)*arg2);
35281 wxPyEndAllowThreads(__tstate);
35282 if (PyErr_Occurred()) SWIG_fail;
35283 }
35284 resultobj = SWIG_Py_Void();
35285 return resultobj;
35286 fail:
35287 return NULL;
35288 }
35289
35290
35291 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35292 PyObject *resultobj = 0;
35293 wxWindow *arg1 = (wxWindow *) 0 ;
35294 wxSize *arg2 = 0 ;
35295 void *argp1 = 0 ;
35296 int res1 = 0 ;
35297 wxSize temp2 ;
35298 PyObject * obj0 = 0 ;
35299 PyObject * obj1 = 0 ;
35300 char * kwnames[] = {
35301 (char *) "self",(char *) "maxSize", NULL
35302 };
35303
35304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
35305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35306 if (!SWIG_IsOK(res1)) {
35307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35308 }
35309 arg1 = reinterpret_cast< wxWindow * >(argp1);
35310 {
35311 arg2 = &temp2;
35312 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35313 }
35314 {
35315 PyThreadState* __tstate = wxPyBeginAllowThreads();
35316 (arg1)->SetMaxSize((wxSize const &)*arg2);
35317 wxPyEndAllowThreads(__tstate);
35318 if (PyErr_Occurred()) SWIG_fail;
35319 }
35320 resultobj = SWIG_Py_Void();
35321 return resultobj;
35322 fail:
35323 return NULL;
35324 }
35325
35326
35327 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35328 PyObject *resultobj = 0;
35329 wxWindow *arg1 = (wxWindow *) 0 ;
35330 int result;
35331 void *argp1 = 0 ;
35332 int res1 = 0 ;
35333 PyObject *swig_obj[1] ;
35334
35335 if (!args) SWIG_fail;
35336 swig_obj[0] = args;
35337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35338 if (!SWIG_IsOK(res1)) {
35339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35340 }
35341 arg1 = reinterpret_cast< wxWindow * >(argp1);
35342 {
35343 PyThreadState* __tstate = wxPyBeginAllowThreads();
35344 result = (int)((wxWindow const *)arg1)->GetMinWidth();
35345 wxPyEndAllowThreads(__tstate);
35346 if (PyErr_Occurred()) SWIG_fail;
35347 }
35348 resultobj = SWIG_From_int(static_cast< int >(result));
35349 return resultobj;
35350 fail:
35351 return NULL;
35352 }
35353
35354
35355 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35356 PyObject *resultobj = 0;
35357 wxWindow *arg1 = (wxWindow *) 0 ;
35358 int result;
35359 void *argp1 = 0 ;
35360 int res1 = 0 ;
35361 PyObject *swig_obj[1] ;
35362
35363 if (!args) SWIG_fail;
35364 swig_obj[0] = args;
35365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35366 if (!SWIG_IsOK(res1)) {
35367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35368 }
35369 arg1 = reinterpret_cast< wxWindow * >(argp1);
35370 {
35371 PyThreadState* __tstate = wxPyBeginAllowThreads();
35372 result = (int)((wxWindow const *)arg1)->GetMinHeight();
35373 wxPyEndAllowThreads(__tstate);
35374 if (PyErr_Occurred()) SWIG_fail;
35375 }
35376 resultobj = SWIG_From_int(static_cast< int >(result));
35377 return resultobj;
35378 fail:
35379 return NULL;
35380 }
35381
35382
35383 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35384 PyObject *resultobj = 0;
35385 wxWindow *arg1 = (wxWindow *) 0 ;
35386 int result;
35387 void *argp1 = 0 ;
35388 int res1 = 0 ;
35389 PyObject *swig_obj[1] ;
35390
35391 if (!args) SWIG_fail;
35392 swig_obj[0] = args;
35393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35394 if (!SWIG_IsOK(res1)) {
35395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35396 }
35397 arg1 = reinterpret_cast< wxWindow * >(argp1);
35398 {
35399 PyThreadState* __tstate = wxPyBeginAllowThreads();
35400 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
35401 wxPyEndAllowThreads(__tstate);
35402 if (PyErr_Occurred()) SWIG_fail;
35403 }
35404 resultobj = SWIG_From_int(static_cast< int >(result));
35405 return resultobj;
35406 fail:
35407 return NULL;
35408 }
35409
35410
35411 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35412 PyObject *resultobj = 0;
35413 wxWindow *arg1 = (wxWindow *) 0 ;
35414 int result;
35415 void *argp1 = 0 ;
35416 int res1 = 0 ;
35417 PyObject *swig_obj[1] ;
35418
35419 if (!args) SWIG_fail;
35420 swig_obj[0] = args;
35421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35422 if (!SWIG_IsOK(res1)) {
35423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35424 }
35425 arg1 = reinterpret_cast< wxWindow * >(argp1);
35426 {
35427 PyThreadState* __tstate = wxPyBeginAllowThreads();
35428 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
35429 wxPyEndAllowThreads(__tstate);
35430 if (PyErr_Occurred()) SWIG_fail;
35431 }
35432 resultobj = SWIG_From_int(static_cast< int >(result));
35433 return resultobj;
35434 fail:
35435 return NULL;
35436 }
35437
35438
35439 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35440 PyObject *resultobj = 0;
35441 wxWindow *arg1 = (wxWindow *) 0 ;
35442 wxSize *arg2 = 0 ;
35443 void *argp1 = 0 ;
35444 int res1 = 0 ;
35445 wxSize temp2 ;
35446 PyObject * obj0 = 0 ;
35447 PyObject * obj1 = 0 ;
35448 char * kwnames[] = {
35449 (char *) "self",(char *) "size", NULL
35450 };
35451
35452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
35453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35454 if (!SWIG_IsOK(res1)) {
35455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35456 }
35457 arg1 = reinterpret_cast< wxWindow * >(argp1);
35458 {
35459 arg2 = &temp2;
35460 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35461 }
35462 {
35463 PyThreadState* __tstate = wxPyBeginAllowThreads();
35464 (arg1)->SetVirtualSize((wxSize const &)*arg2);
35465 wxPyEndAllowThreads(__tstate);
35466 if (PyErr_Occurred()) SWIG_fail;
35467 }
35468 resultobj = SWIG_Py_Void();
35469 return resultobj;
35470 fail:
35471 return NULL;
35472 }
35473
35474
35475 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35476 PyObject *resultobj = 0;
35477 wxWindow *arg1 = (wxWindow *) 0 ;
35478 int arg2 ;
35479 int arg3 ;
35480 void *argp1 = 0 ;
35481 int res1 = 0 ;
35482 int val2 ;
35483 int ecode2 = 0 ;
35484 int val3 ;
35485 int ecode3 = 0 ;
35486 PyObject * obj0 = 0 ;
35487 PyObject * obj1 = 0 ;
35488 PyObject * obj2 = 0 ;
35489 char * kwnames[] = {
35490 (char *) "self",(char *) "w",(char *) "h", NULL
35491 };
35492
35493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35495 if (!SWIG_IsOK(res1)) {
35496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
35497 }
35498 arg1 = reinterpret_cast< wxWindow * >(argp1);
35499 ecode2 = SWIG_AsVal_int(obj1, &val2);
35500 if (!SWIG_IsOK(ecode2)) {
35501 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
35502 }
35503 arg2 = static_cast< int >(val2);
35504 ecode3 = SWIG_AsVal_int(obj2, &val3);
35505 if (!SWIG_IsOK(ecode3)) {
35506 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
35507 }
35508 arg3 = static_cast< int >(val3);
35509 {
35510 PyThreadState* __tstate = wxPyBeginAllowThreads();
35511 (arg1)->SetVirtualSize(arg2,arg3);
35512 wxPyEndAllowThreads(__tstate);
35513 if (PyErr_Occurred()) SWIG_fail;
35514 }
35515 resultobj = SWIG_Py_Void();
35516 return resultobj;
35517 fail:
35518 return NULL;
35519 }
35520
35521
35522 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35523 PyObject *resultobj = 0;
35524 wxWindow *arg1 = (wxWindow *) 0 ;
35525 wxSize result;
35526 void *argp1 = 0 ;
35527 int res1 = 0 ;
35528 PyObject *swig_obj[1] ;
35529
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_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35535 }
35536 arg1 = reinterpret_cast< wxWindow * >(argp1);
35537 {
35538 PyThreadState* __tstate = wxPyBeginAllowThreads();
35539 result = ((wxWindow const *)arg1)->GetVirtualSize();
35540 wxPyEndAllowThreads(__tstate);
35541 if (PyErr_Occurred()) SWIG_fail;
35542 }
35543 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35544 return resultobj;
35545 fail:
35546 return NULL;
35547 }
35548
35549
35550 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35551 PyObject *resultobj = 0;
35552 wxWindow *arg1 = (wxWindow *) 0 ;
35553 int *arg2 = (int *) 0 ;
35554 int *arg3 = (int *) 0 ;
35555 void *argp1 = 0 ;
35556 int res1 = 0 ;
35557 int temp2 ;
35558 int res2 = SWIG_TMPOBJ ;
35559 int temp3 ;
35560 int res3 = SWIG_TMPOBJ ;
35561 PyObject *swig_obj[1] ;
35562
35563 arg2 = &temp2;
35564 arg3 = &temp3;
35565 if (!args) SWIG_fail;
35566 swig_obj[0] = args;
35567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35568 if (!SWIG_IsOK(res1)) {
35569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
35570 }
35571 arg1 = reinterpret_cast< wxWindow * >(argp1);
35572 {
35573 PyThreadState* __tstate = wxPyBeginAllowThreads();
35574 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
35575 wxPyEndAllowThreads(__tstate);
35576 if (PyErr_Occurred()) SWIG_fail;
35577 }
35578 resultobj = SWIG_Py_Void();
35579 if (SWIG_IsTmpObj(res2)) {
35580 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35581 } else {
35582 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35583 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35584 }
35585 if (SWIG_IsTmpObj(res3)) {
35586 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35587 } else {
35588 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35589 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35590 }
35591 return resultobj;
35592 fail:
35593 return NULL;
35594 }
35595
35596
35597 SWIGINTERN PyObject *_wrap_Window_GetWindowBorderSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35598 PyObject *resultobj = 0;
35599 wxWindow *arg1 = (wxWindow *) 0 ;
35600 wxSize result;
35601 void *argp1 = 0 ;
35602 int res1 = 0 ;
35603 PyObject *swig_obj[1] ;
35604
35605 if (!args) SWIG_fail;
35606 swig_obj[0] = args;
35607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35608 if (!SWIG_IsOK(res1)) {
35609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowBorderSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35610 }
35611 arg1 = reinterpret_cast< wxWindow * >(argp1);
35612 {
35613 PyThreadState* __tstate = wxPyBeginAllowThreads();
35614 result = ((wxWindow const *)arg1)->GetWindowBorderSize();
35615 wxPyEndAllowThreads(__tstate);
35616 if (PyErr_Occurred()) SWIG_fail;
35617 }
35618 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35619 return resultobj;
35620 fail:
35621 return NULL;
35622 }
35623
35624
35625 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35626 PyObject *resultobj = 0;
35627 wxWindow *arg1 = (wxWindow *) 0 ;
35628 wxSize result;
35629 void *argp1 = 0 ;
35630 int res1 = 0 ;
35631 PyObject *swig_obj[1] ;
35632
35633 if (!args) SWIG_fail;
35634 swig_obj[0] = args;
35635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35636 if (!SWIG_IsOK(res1)) {
35637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35638 }
35639 arg1 = reinterpret_cast< wxWindow * >(argp1);
35640 {
35641 PyThreadState* __tstate = wxPyBeginAllowThreads();
35642 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
35643 wxPyEndAllowThreads(__tstate);
35644 if (PyErr_Occurred()) SWIG_fail;
35645 }
35646 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35647 return resultobj;
35648 fail:
35649 return NULL;
35650 }
35651
35652
35653 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35654 PyObject *resultobj = 0;
35655 wxWindow *arg1 = (wxWindow *) 0 ;
35656 bool arg2 = (bool) true ;
35657 bool result;
35658 void *argp1 = 0 ;
35659 int res1 = 0 ;
35660 bool val2 ;
35661 int ecode2 = 0 ;
35662 PyObject * obj0 = 0 ;
35663 PyObject * obj1 = 0 ;
35664 char * kwnames[] = {
35665 (char *) "self",(char *) "show", NULL
35666 };
35667
35668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
35669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35670 if (!SWIG_IsOK(res1)) {
35671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
35672 }
35673 arg1 = reinterpret_cast< wxWindow * >(argp1);
35674 if (obj1) {
35675 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35676 if (!SWIG_IsOK(ecode2)) {
35677 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
35678 }
35679 arg2 = static_cast< bool >(val2);
35680 }
35681 {
35682 PyThreadState* __tstate = wxPyBeginAllowThreads();
35683 result = (bool)(arg1)->Show(arg2);
35684 wxPyEndAllowThreads(__tstate);
35685 if (PyErr_Occurred()) SWIG_fail;
35686 }
35687 {
35688 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35689 }
35690 return resultobj;
35691 fail:
35692 return NULL;
35693 }
35694
35695
35696 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35697 PyObject *resultobj = 0;
35698 wxWindow *arg1 = (wxWindow *) 0 ;
35699 bool result;
35700 void *argp1 = 0 ;
35701 int res1 = 0 ;
35702 PyObject *swig_obj[1] ;
35703
35704 if (!args) SWIG_fail;
35705 swig_obj[0] = args;
35706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35707 if (!SWIG_IsOK(res1)) {
35708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
35709 }
35710 arg1 = reinterpret_cast< wxWindow * >(argp1);
35711 {
35712 PyThreadState* __tstate = wxPyBeginAllowThreads();
35713 result = (bool)(arg1)->Hide();
35714 wxPyEndAllowThreads(__tstate);
35715 if (PyErr_Occurred()) SWIG_fail;
35716 }
35717 {
35718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35719 }
35720 return resultobj;
35721 fail:
35722 return NULL;
35723 }
35724
35725
35726 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35727 PyObject *resultobj = 0;
35728 wxWindow *arg1 = (wxWindow *) 0 ;
35729 bool arg2 = (bool) true ;
35730 bool result;
35731 void *argp1 = 0 ;
35732 int res1 = 0 ;
35733 bool val2 ;
35734 int ecode2 = 0 ;
35735 PyObject * obj0 = 0 ;
35736 PyObject * obj1 = 0 ;
35737 char * kwnames[] = {
35738 (char *) "self",(char *) "enable", NULL
35739 };
35740
35741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
35742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35743 if (!SWIG_IsOK(res1)) {
35744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
35745 }
35746 arg1 = reinterpret_cast< wxWindow * >(argp1);
35747 if (obj1) {
35748 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35749 if (!SWIG_IsOK(ecode2)) {
35750 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
35751 }
35752 arg2 = static_cast< bool >(val2);
35753 }
35754 {
35755 PyThreadState* __tstate = wxPyBeginAllowThreads();
35756 result = (bool)(arg1)->Enable(arg2);
35757 wxPyEndAllowThreads(__tstate);
35758 if (PyErr_Occurred()) SWIG_fail;
35759 }
35760 {
35761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35762 }
35763 return resultobj;
35764 fail:
35765 return NULL;
35766 }
35767
35768
35769 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35770 PyObject *resultobj = 0;
35771 wxWindow *arg1 = (wxWindow *) 0 ;
35772 bool result;
35773 void *argp1 = 0 ;
35774 int res1 = 0 ;
35775 PyObject *swig_obj[1] ;
35776
35777 if (!args) SWIG_fail;
35778 swig_obj[0] = args;
35779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35780 if (!SWIG_IsOK(res1)) {
35781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
35782 }
35783 arg1 = reinterpret_cast< wxWindow * >(argp1);
35784 {
35785 PyThreadState* __tstate = wxPyBeginAllowThreads();
35786 result = (bool)(arg1)->Disable();
35787 wxPyEndAllowThreads(__tstate);
35788 if (PyErr_Occurred()) SWIG_fail;
35789 }
35790 {
35791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35792 }
35793 return resultobj;
35794 fail:
35795 return NULL;
35796 }
35797
35798
35799 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35800 PyObject *resultobj = 0;
35801 wxWindow *arg1 = (wxWindow *) 0 ;
35802 bool result;
35803 void *argp1 = 0 ;
35804 int res1 = 0 ;
35805 PyObject *swig_obj[1] ;
35806
35807 if (!args) SWIG_fail;
35808 swig_obj[0] = args;
35809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35810 if (!SWIG_IsOK(res1)) {
35811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
35812 }
35813 arg1 = reinterpret_cast< wxWindow * >(argp1);
35814 {
35815 PyThreadState* __tstate = wxPyBeginAllowThreads();
35816 result = (bool)((wxWindow const *)arg1)->IsShown();
35817 wxPyEndAllowThreads(__tstate);
35818 if (PyErr_Occurred()) SWIG_fail;
35819 }
35820 {
35821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35822 }
35823 return resultobj;
35824 fail:
35825 return NULL;
35826 }
35827
35828
35829 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35830 PyObject *resultobj = 0;
35831 wxWindow *arg1 = (wxWindow *) 0 ;
35832 bool result;
35833 void *argp1 = 0 ;
35834 int res1 = 0 ;
35835 PyObject *swig_obj[1] ;
35836
35837 if (!args) SWIG_fail;
35838 swig_obj[0] = args;
35839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35840 if (!SWIG_IsOK(res1)) {
35841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
35842 }
35843 arg1 = reinterpret_cast< wxWindow * >(argp1);
35844 {
35845 PyThreadState* __tstate = wxPyBeginAllowThreads();
35846 result = (bool)((wxWindow const *)arg1)->IsEnabled();
35847 wxPyEndAllowThreads(__tstate);
35848 if (PyErr_Occurred()) SWIG_fail;
35849 }
35850 {
35851 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35852 }
35853 return resultobj;
35854 fail:
35855 return NULL;
35856 }
35857
35858
35859 SWIGINTERN PyObject *_wrap_Window_IsThisEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35860 PyObject *resultobj = 0;
35861 wxWindow *arg1 = (wxWindow *) 0 ;
35862 bool result;
35863 void *argp1 = 0 ;
35864 int res1 = 0 ;
35865 PyObject *swig_obj[1] ;
35866
35867 if (!args) SWIG_fail;
35868 swig_obj[0] = args;
35869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35870 if (!SWIG_IsOK(res1)) {
35871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsThisEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
35872 }
35873 arg1 = reinterpret_cast< wxWindow * >(argp1);
35874 {
35875 PyThreadState* __tstate = wxPyBeginAllowThreads();
35876 result = (bool)((wxWindow const *)arg1)->IsThisEnabled();
35877 wxPyEndAllowThreads(__tstate);
35878 if (PyErr_Occurred()) SWIG_fail;
35879 }
35880 {
35881 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35882 }
35883 return resultobj;
35884 fail:
35885 return NULL;
35886 }
35887
35888
35889 SWIGINTERN PyObject *_wrap_Window_IsShownOnScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35890 PyObject *resultobj = 0;
35891 wxWindow *arg1 = (wxWindow *) 0 ;
35892 bool result;
35893 void *argp1 = 0 ;
35894 int res1 = 0 ;
35895 PyObject *swig_obj[1] ;
35896
35897 if (!args) SWIG_fail;
35898 swig_obj[0] = args;
35899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35900 if (!SWIG_IsOK(res1)) {
35901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShownOnScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35902 }
35903 arg1 = reinterpret_cast< wxWindow * >(argp1);
35904 {
35905 PyThreadState* __tstate = wxPyBeginAllowThreads();
35906 result = (bool)((wxWindow const *)arg1)->IsShownOnScreen();
35907 wxPyEndAllowThreads(__tstate);
35908 if (PyErr_Occurred()) SWIG_fail;
35909 }
35910 {
35911 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35912 }
35913 return resultobj;
35914 fail:
35915 return NULL;
35916 }
35917
35918
35919 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35920 PyObject *resultobj = 0;
35921 wxWindow *arg1 = (wxWindow *) 0 ;
35922 long arg2 ;
35923 void *argp1 = 0 ;
35924 int res1 = 0 ;
35925 long val2 ;
35926 int ecode2 = 0 ;
35927 PyObject * obj0 = 0 ;
35928 PyObject * obj1 = 0 ;
35929 char * kwnames[] = {
35930 (char *) "self",(char *) "style", NULL
35931 };
35932
35933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
35934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35935 if (!SWIG_IsOK(res1)) {
35936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
35937 }
35938 arg1 = reinterpret_cast< wxWindow * >(argp1);
35939 ecode2 = SWIG_AsVal_long(obj1, &val2);
35940 if (!SWIG_IsOK(ecode2)) {
35941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
35942 }
35943 arg2 = static_cast< long >(val2);
35944 {
35945 PyThreadState* __tstate = wxPyBeginAllowThreads();
35946 (arg1)->SetWindowStyleFlag(arg2);
35947 wxPyEndAllowThreads(__tstate);
35948 if (PyErr_Occurred()) SWIG_fail;
35949 }
35950 resultobj = SWIG_Py_Void();
35951 return resultobj;
35952 fail:
35953 return NULL;
35954 }
35955
35956
35957 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35958 PyObject *resultobj = 0;
35959 wxWindow *arg1 = (wxWindow *) 0 ;
35960 long result;
35961 void *argp1 = 0 ;
35962 int res1 = 0 ;
35963 PyObject *swig_obj[1] ;
35964
35965 if (!args) SWIG_fail;
35966 swig_obj[0] = args;
35967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35968 if (!SWIG_IsOK(res1)) {
35969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
35970 }
35971 arg1 = reinterpret_cast< wxWindow * >(argp1);
35972 {
35973 PyThreadState* __tstate = wxPyBeginAllowThreads();
35974 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
35975 wxPyEndAllowThreads(__tstate);
35976 if (PyErr_Occurred()) SWIG_fail;
35977 }
35978 resultobj = SWIG_From_long(static_cast< long >(result));
35979 return resultobj;
35980 fail:
35981 return NULL;
35982 }
35983
35984
35985 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35986 PyObject *resultobj = 0;
35987 wxWindow *arg1 = (wxWindow *) 0 ;
35988 int arg2 ;
35989 bool result;
35990 void *argp1 = 0 ;
35991 int res1 = 0 ;
35992 int val2 ;
35993 int ecode2 = 0 ;
35994 PyObject * obj0 = 0 ;
35995 PyObject * obj1 = 0 ;
35996 char * kwnames[] = {
35997 (char *) "self",(char *) "flag", NULL
35998 };
35999
36000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
36001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36002 if (!SWIG_IsOK(res1)) {
36003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
36004 }
36005 arg1 = reinterpret_cast< wxWindow * >(argp1);
36006 ecode2 = SWIG_AsVal_int(obj1, &val2);
36007 if (!SWIG_IsOK(ecode2)) {
36008 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
36009 }
36010 arg2 = static_cast< int >(val2);
36011 {
36012 PyThreadState* __tstate = wxPyBeginAllowThreads();
36013 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
36014 wxPyEndAllowThreads(__tstate);
36015 if (PyErr_Occurred()) SWIG_fail;
36016 }
36017 {
36018 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36019 }
36020 return resultobj;
36021 fail:
36022 return NULL;
36023 }
36024
36025
36026 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36027 PyObject *resultobj = 0;
36028 wxWindow *arg1 = (wxWindow *) 0 ;
36029 bool result;
36030 void *argp1 = 0 ;
36031 int res1 = 0 ;
36032 PyObject *swig_obj[1] ;
36033
36034 if (!args) SWIG_fail;
36035 swig_obj[0] = args;
36036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36037 if (!SWIG_IsOK(res1)) {
36038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
36039 }
36040 arg1 = reinterpret_cast< wxWindow * >(argp1);
36041 {
36042 PyThreadState* __tstate = wxPyBeginAllowThreads();
36043 result = (bool)((wxWindow const *)arg1)->IsRetained();
36044 wxPyEndAllowThreads(__tstate);
36045 if (PyErr_Occurred()) SWIG_fail;
36046 }
36047 {
36048 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36049 }
36050 return resultobj;
36051 fail:
36052 return NULL;
36053 }
36054
36055
36056 SWIGINTERN PyObject *_wrap_Window_ToggleWindowStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36057 PyObject *resultobj = 0;
36058 wxWindow *arg1 = (wxWindow *) 0 ;
36059 int arg2 ;
36060 bool result;
36061 void *argp1 = 0 ;
36062 int res1 = 0 ;
36063 int val2 ;
36064 int ecode2 = 0 ;
36065 PyObject * obj0 = 0 ;
36066 PyObject * obj1 = 0 ;
36067 char * kwnames[] = {
36068 (char *) "self",(char *) "flag", NULL
36069 };
36070
36071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ToggleWindowStyle",kwnames,&obj0,&obj1)) SWIG_fail;
36072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36073 if (!SWIG_IsOK(res1)) {
36074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ToggleWindowStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
36075 }
36076 arg1 = reinterpret_cast< wxWindow * >(argp1);
36077 ecode2 = SWIG_AsVal_int(obj1, &val2);
36078 if (!SWIG_IsOK(ecode2)) {
36079 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ToggleWindowStyle" "', expected argument " "2"" of type '" "int""'");
36080 }
36081 arg2 = static_cast< int >(val2);
36082 {
36083 PyThreadState* __tstate = wxPyBeginAllowThreads();
36084 result = (bool)(arg1)->ToggleWindowStyle(arg2);
36085 wxPyEndAllowThreads(__tstate);
36086 if (PyErr_Occurred()) SWIG_fail;
36087 }
36088 {
36089 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36090 }
36091 return resultobj;
36092 fail:
36093 return NULL;
36094 }
36095
36096
36097 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36098 PyObject *resultobj = 0;
36099 wxWindow *arg1 = (wxWindow *) 0 ;
36100 long arg2 ;
36101 void *argp1 = 0 ;
36102 int res1 = 0 ;
36103 long val2 ;
36104 int ecode2 = 0 ;
36105 PyObject * obj0 = 0 ;
36106 PyObject * obj1 = 0 ;
36107 char * kwnames[] = {
36108 (char *) "self",(char *) "exStyle", NULL
36109 };
36110
36111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
36112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36113 if (!SWIG_IsOK(res1)) {
36114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
36115 }
36116 arg1 = reinterpret_cast< wxWindow * >(argp1);
36117 ecode2 = SWIG_AsVal_long(obj1, &val2);
36118 if (!SWIG_IsOK(ecode2)) {
36119 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
36120 }
36121 arg2 = static_cast< long >(val2);
36122 {
36123 PyThreadState* __tstate = wxPyBeginAllowThreads();
36124 (arg1)->SetExtraStyle(arg2);
36125 wxPyEndAllowThreads(__tstate);
36126 if (PyErr_Occurred()) SWIG_fail;
36127 }
36128 resultobj = SWIG_Py_Void();
36129 return resultobj;
36130 fail:
36131 return NULL;
36132 }
36133
36134
36135 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36136 PyObject *resultobj = 0;
36137 wxWindow *arg1 = (wxWindow *) 0 ;
36138 long result;
36139 void *argp1 = 0 ;
36140 int res1 = 0 ;
36141 PyObject *swig_obj[1] ;
36142
36143 if (!args) SWIG_fail;
36144 swig_obj[0] = args;
36145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36146 if (!SWIG_IsOK(res1)) {
36147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
36148 }
36149 arg1 = reinterpret_cast< wxWindow * >(argp1);
36150 {
36151 PyThreadState* __tstate = wxPyBeginAllowThreads();
36152 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
36153 wxPyEndAllowThreads(__tstate);
36154 if (PyErr_Occurred()) SWIG_fail;
36155 }
36156 resultobj = SWIG_From_long(static_cast< long >(result));
36157 return resultobj;
36158 fail:
36159 return NULL;
36160 }
36161
36162
36163 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36164 PyObject *resultobj = 0;
36165 wxWindow *arg1 = (wxWindow *) 0 ;
36166 bool arg2 = (bool) true ;
36167 void *argp1 = 0 ;
36168 int res1 = 0 ;
36169 bool val2 ;
36170 int ecode2 = 0 ;
36171 PyObject * obj0 = 0 ;
36172 PyObject * obj1 = 0 ;
36173 char * kwnames[] = {
36174 (char *) "self",(char *) "modal", NULL
36175 };
36176
36177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
36178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36179 if (!SWIG_IsOK(res1)) {
36180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
36181 }
36182 arg1 = reinterpret_cast< wxWindow * >(argp1);
36183 if (obj1) {
36184 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36185 if (!SWIG_IsOK(ecode2)) {
36186 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
36187 }
36188 arg2 = static_cast< bool >(val2);
36189 }
36190 {
36191 PyThreadState* __tstate = wxPyBeginAllowThreads();
36192 (arg1)->MakeModal(arg2);
36193 wxPyEndAllowThreads(__tstate);
36194 if (PyErr_Occurred()) SWIG_fail;
36195 }
36196 resultobj = SWIG_Py_Void();
36197 return resultobj;
36198 fail:
36199 return NULL;
36200 }
36201
36202
36203 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36204 PyObject *resultobj = 0;
36205 wxWindow *arg1 = (wxWindow *) 0 ;
36206 bool arg2 ;
36207 void *argp1 = 0 ;
36208 int res1 = 0 ;
36209 bool val2 ;
36210 int ecode2 = 0 ;
36211 PyObject * obj0 = 0 ;
36212 PyObject * obj1 = 0 ;
36213 char * kwnames[] = {
36214 (char *) "self",(char *) "enableTheme", NULL
36215 };
36216
36217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
36218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36219 if (!SWIG_IsOK(res1)) {
36220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
36221 }
36222 arg1 = reinterpret_cast< wxWindow * >(argp1);
36223 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36224 if (!SWIG_IsOK(ecode2)) {
36225 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
36226 }
36227 arg2 = static_cast< bool >(val2);
36228 {
36229 PyThreadState* __tstate = wxPyBeginAllowThreads();
36230 (arg1)->SetThemeEnabled(arg2);
36231 wxPyEndAllowThreads(__tstate);
36232 if (PyErr_Occurred()) SWIG_fail;
36233 }
36234 resultobj = SWIG_Py_Void();
36235 return resultobj;
36236 fail:
36237 return NULL;
36238 }
36239
36240
36241 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36242 PyObject *resultobj = 0;
36243 wxWindow *arg1 = (wxWindow *) 0 ;
36244 bool result;
36245 void *argp1 = 0 ;
36246 int res1 = 0 ;
36247 PyObject *swig_obj[1] ;
36248
36249 if (!args) SWIG_fail;
36250 swig_obj[0] = args;
36251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36252 if (!SWIG_IsOK(res1)) {
36253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
36254 }
36255 arg1 = reinterpret_cast< wxWindow * >(argp1);
36256 {
36257 PyThreadState* __tstate = wxPyBeginAllowThreads();
36258 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
36259 wxPyEndAllowThreads(__tstate);
36260 if (PyErr_Occurred()) SWIG_fail;
36261 }
36262 {
36263 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36264 }
36265 return resultobj;
36266 fail:
36267 return NULL;
36268 }
36269
36270
36271 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36272 PyObject *resultobj = 0;
36273 wxWindow *arg1 = (wxWindow *) 0 ;
36274 void *argp1 = 0 ;
36275 int res1 = 0 ;
36276 PyObject *swig_obj[1] ;
36277
36278 if (!args) SWIG_fail;
36279 swig_obj[0] = args;
36280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36281 if (!SWIG_IsOK(res1)) {
36282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
36283 }
36284 arg1 = reinterpret_cast< wxWindow * >(argp1);
36285 {
36286 PyThreadState* __tstate = wxPyBeginAllowThreads();
36287 (arg1)->SetFocus();
36288 wxPyEndAllowThreads(__tstate);
36289 if (PyErr_Occurred()) SWIG_fail;
36290 }
36291 resultobj = SWIG_Py_Void();
36292 return resultobj;
36293 fail:
36294 return NULL;
36295 }
36296
36297
36298 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36299 PyObject *resultobj = 0;
36300 wxWindow *arg1 = (wxWindow *) 0 ;
36301 void *argp1 = 0 ;
36302 int res1 = 0 ;
36303 PyObject *swig_obj[1] ;
36304
36305 if (!args) SWIG_fail;
36306 swig_obj[0] = args;
36307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36308 if (!SWIG_IsOK(res1)) {
36309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
36310 }
36311 arg1 = reinterpret_cast< wxWindow * >(argp1);
36312 {
36313 PyThreadState* __tstate = wxPyBeginAllowThreads();
36314 (arg1)->SetFocusFromKbd();
36315 wxPyEndAllowThreads(__tstate);
36316 if (PyErr_Occurred()) SWIG_fail;
36317 }
36318 resultobj = SWIG_Py_Void();
36319 return resultobj;
36320 fail:
36321 return NULL;
36322 }
36323
36324
36325 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36326 PyObject *resultobj = 0;
36327 wxWindow *result = 0 ;
36328
36329 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
36330 {
36331 if (!wxPyCheckForApp()) SWIG_fail;
36332 PyThreadState* __tstate = wxPyBeginAllowThreads();
36333 result = (wxWindow *)wxWindow::FindFocus();
36334 wxPyEndAllowThreads(__tstate);
36335 if (PyErr_Occurred()) SWIG_fail;
36336 }
36337 {
36338 resultobj = wxPyMake_wxObject(result, 0);
36339 }
36340 return resultobj;
36341 fail:
36342 return NULL;
36343 }
36344
36345
36346 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36347 PyObject *resultobj = 0;
36348 wxWindow *arg1 = (wxWindow *) 0 ;
36349 bool result;
36350 void *argp1 = 0 ;
36351 int res1 = 0 ;
36352 PyObject *swig_obj[1] ;
36353
36354 if (!args) SWIG_fail;
36355 swig_obj[0] = args;
36356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36357 if (!SWIG_IsOK(res1)) {
36358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
36359 }
36360 arg1 = reinterpret_cast< wxWindow * >(argp1);
36361 {
36362 PyThreadState* __tstate = wxPyBeginAllowThreads();
36363 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
36364 wxPyEndAllowThreads(__tstate);
36365 if (PyErr_Occurred()) SWIG_fail;
36366 }
36367 {
36368 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36369 }
36370 return resultobj;
36371 fail:
36372 return NULL;
36373 }
36374
36375
36376 SWIGINTERN PyObject *_wrap_Window_CanAcceptFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36377 PyObject *resultobj = 0;
36378 wxWindow *arg1 = (wxWindow *) 0 ;
36379 bool result;
36380 void *argp1 = 0 ;
36381 int res1 = 0 ;
36382 PyObject *swig_obj[1] ;
36383
36384 if (!args) SWIG_fail;
36385 swig_obj[0] = args;
36386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36387 if (!SWIG_IsOK(res1)) {
36388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanAcceptFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
36389 }
36390 arg1 = reinterpret_cast< wxWindow * >(argp1);
36391 {
36392 PyThreadState* __tstate = wxPyBeginAllowThreads();
36393 result = (bool)((wxWindow const *)arg1)->CanAcceptFocus();
36394 wxPyEndAllowThreads(__tstate);
36395 if (PyErr_Occurred()) SWIG_fail;
36396 }
36397 {
36398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36399 }
36400 return resultobj;
36401 fail:
36402 return NULL;
36403 }
36404
36405
36406 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36407 PyObject *resultobj = 0;
36408 wxWindow *arg1 = (wxWindow *) 0 ;
36409 bool result;
36410 void *argp1 = 0 ;
36411 int res1 = 0 ;
36412 PyObject *swig_obj[1] ;
36413
36414 if (!args) SWIG_fail;
36415 swig_obj[0] = args;
36416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36417 if (!SWIG_IsOK(res1)) {
36418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
36419 }
36420 arg1 = reinterpret_cast< wxWindow * >(argp1);
36421 {
36422 PyThreadState* __tstate = wxPyBeginAllowThreads();
36423 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
36424 wxPyEndAllowThreads(__tstate);
36425 if (PyErr_Occurred()) SWIG_fail;
36426 }
36427 {
36428 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36429 }
36430 return resultobj;
36431 fail:
36432 return NULL;
36433 }
36434
36435
36436 SWIGINTERN PyObject *_wrap_Window_CanAcceptFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36437 PyObject *resultobj = 0;
36438 wxWindow *arg1 = (wxWindow *) 0 ;
36439 bool result;
36440 void *argp1 = 0 ;
36441 int res1 = 0 ;
36442 PyObject *swig_obj[1] ;
36443
36444 if (!args) SWIG_fail;
36445 swig_obj[0] = args;
36446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36447 if (!SWIG_IsOK(res1)) {
36448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanAcceptFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
36449 }
36450 arg1 = reinterpret_cast< wxWindow * >(argp1);
36451 {
36452 PyThreadState* __tstate = wxPyBeginAllowThreads();
36453 result = (bool)((wxWindow const *)arg1)->CanAcceptFocusFromKeyboard();
36454 wxPyEndAllowThreads(__tstate);
36455 if (PyErr_Occurred()) SWIG_fail;
36456 }
36457 {
36458 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36459 }
36460 return resultobj;
36461 fail:
36462 return NULL;
36463 }
36464
36465
36466 SWIGINTERN PyObject *_wrap_Window_NavigateIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36467 PyObject *resultobj = 0;
36468 wxWindow *arg1 = (wxWindow *) 0 ;
36469 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
36470 bool result;
36471 void *argp1 = 0 ;
36472 int res1 = 0 ;
36473 int val2 ;
36474 int ecode2 = 0 ;
36475 PyObject * obj0 = 0 ;
36476 PyObject * obj1 = 0 ;
36477 char * kwnames[] = {
36478 (char *) "self",(char *) "flags", NULL
36479 };
36480
36481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_NavigateIn",kwnames,&obj0,&obj1)) SWIG_fail;
36482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36483 if (!SWIG_IsOK(res1)) {
36484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_NavigateIn" "', expected argument " "1"" of type '" "wxWindow *""'");
36485 }
36486 arg1 = reinterpret_cast< wxWindow * >(argp1);
36487 if (obj1) {
36488 ecode2 = SWIG_AsVal_int(obj1, &val2);
36489 if (!SWIG_IsOK(ecode2)) {
36490 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_NavigateIn" "', expected argument " "2"" of type '" "int""'");
36491 }
36492 arg2 = static_cast< int >(val2);
36493 }
36494 {
36495 PyThreadState* __tstate = wxPyBeginAllowThreads();
36496 result = (bool)(arg1)->NavigateIn(arg2);
36497 wxPyEndAllowThreads(__tstate);
36498 if (PyErr_Occurred()) SWIG_fail;
36499 }
36500 {
36501 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36502 }
36503 return resultobj;
36504 fail:
36505 return NULL;
36506 }
36507
36508
36509 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36510 PyObject *resultobj = 0;
36511 wxWindow *arg1 = (wxWindow *) 0 ;
36512 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
36513 bool result;
36514 void *argp1 = 0 ;
36515 int res1 = 0 ;
36516 int val2 ;
36517 int ecode2 = 0 ;
36518 PyObject * obj0 = 0 ;
36519 PyObject * obj1 = 0 ;
36520 char * kwnames[] = {
36521 (char *) "self",(char *) "flags", NULL
36522 };
36523
36524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
36525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36526 if (!SWIG_IsOK(res1)) {
36527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
36528 }
36529 arg1 = reinterpret_cast< wxWindow * >(argp1);
36530 if (obj1) {
36531 ecode2 = SWIG_AsVal_int(obj1, &val2);
36532 if (!SWIG_IsOK(ecode2)) {
36533 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
36534 }
36535 arg2 = static_cast< int >(val2);
36536 }
36537 {
36538 PyThreadState* __tstate = wxPyBeginAllowThreads();
36539 result = (bool)(arg1)->Navigate(arg2);
36540 wxPyEndAllowThreads(__tstate);
36541 if (PyErr_Occurred()) SWIG_fail;
36542 }
36543 {
36544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36545 }
36546 return resultobj;
36547 fail:
36548 return NULL;
36549 }
36550
36551
36552 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36553 PyObject *resultobj = 0;
36554 wxWindow *arg1 = (wxWindow *) 0 ;
36555 wxWindow *arg2 = (wxWindow *) 0 ;
36556 void *argp1 = 0 ;
36557 int res1 = 0 ;
36558 void *argp2 = 0 ;
36559 int res2 = 0 ;
36560 PyObject * obj0 = 0 ;
36561 PyObject * obj1 = 0 ;
36562 char * kwnames[] = {
36563 (char *) "self",(char *) "win", NULL
36564 };
36565
36566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
36567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36568 if (!SWIG_IsOK(res1)) {
36569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
36570 }
36571 arg1 = reinterpret_cast< wxWindow * >(argp1);
36572 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36573 if (!SWIG_IsOK(res2)) {
36574 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
36575 }
36576 arg2 = reinterpret_cast< wxWindow * >(argp2);
36577 {
36578 PyThreadState* __tstate = wxPyBeginAllowThreads();
36579 (arg1)->MoveAfterInTabOrder(arg2);
36580 wxPyEndAllowThreads(__tstate);
36581 if (PyErr_Occurred()) SWIG_fail;
36582 }
36583 resultobj = SWIG_Py_Void();
36584 return resultobj;
36585 fail:
36586 return NULL;
36587 }
36588
36589
36590 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36591 PyObject *resultobj = 0;
36592 wxWindow *arg1 = (wxWindow *) 0 ;
36593 wxWindow *arg2 = (wxWindow *) 0 ;
36594 void *argp1 = 0 ;
36595 int res1 = 0 ;
36596 void *argp2 = 0 ;
36597 int res2 = 0 ;
36598 PyObject * obj0 = 0 ;
36599 PyObject * obj1 = 0 ;
36600 char * kwnames[] = {
36601 (char *) "self",(char *) "win", NULL
36602 };
36603
36604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
36605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36606 if (!SWIG_IsOK(res1)) {
36607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
36608 }
36609 arg1 = reinterpret_cast< wxWindow * >(argp1);
36610 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36611 if (!SWIG_IsOK(res2)) {
36612 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
36613 }
36614 arg2 = reinterpret_cast< wxWindow * >(argp2);
36615 {
36616 PyThreadState* __tstate = wxPyBeginAllowThreads();
36617 (arg1)->MoveBeforeInTabOrder(arg2);
36618 wxPyEndAllowThreads(__tstate);
36619 if (PyErr_Occurred()) SWIG_fail;
36620 }
36621 resultobj = SWIG_Py_Void();
36622 return resultobj;
36623 fail:
36624 return NULL;
36625 }
36626
36627
36628 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36629 PyObject *resultobj = 0;
36630 wxWindow *arg1 = (wxWindow *) 0 ;
36631 PyObject *result = 0 ;
36632 void *argp1 = 0 ;
36633 int res1 = 0 ;
36634 PyObject *swig_obj[1] ;
36635
36636 if (!args) SWIG_fail;
36637 swig_obj[0] = args;
36638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36639 if (!SWIG_IsOK(res1)) {
36640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
36641 }
36642 arg1 = reinterpret_cast< wxWindow * >(argp1);
36643 {
36644 PyThreadState* __tstate = wxPyBeginAllowThreads();
36645 result = (PyObject *)wxWindow_GetChildren(arg1);
36646 wxPyEndAllowThreads(__tstate);
36647 if (PyErr_Occurred()) SWIG_fail;
36648 }
36649 resultobj = result;
36650 return resultobj;
36651 fail:
36652 return NULL;
36653 }
36654
36655
36656 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36657 PyObject *resultobj = 0;
36658 wxWindow *arg1 = (wxWindow *) 0 ;
36659 wxWindow *result = 0 ;
36660 void *argp1 = 0 ;
36661 int res1 = 0 ;
36662 PyObject *swig_obj[1] ;
36663
36664 if (!args) SWIG_fail;
36665 swig_obj[0] = args;
36666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36667 if (!SWIG_IsOK(res1)) {
36668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
36669 }
36670 arg1 = reinterpret_cast< wxWindow * >(argp1);
36671 {
36672 PyThreadState* __tstate = wxPyBeginAllowThreads();
36673 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
36674 wxPyEndAllowThreads(__tstate);
36675 if (PyErr_Occurred()) SWIG_fail;
36676 }
36677 {
36678 resultobj = wxPyMake_wxObject(result, 0);
36679 }
36680 return resultobj;
36681 fail:
36682 return NULL;
36683 }
36684
36685
36686 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36687 PyObject *resultobj = 0;
36688 wxWindow *arg1 = (wxWindow *) 0 ;
36689 wxWindow *result = 0 ;
36690 void *argp1 = 0 ;
36691 int res1 = 0 ;
36692 PyObject *swig_obj[1] ;
36693
36694 if (!args) SWIG_fail;
36695 swig_obj[0] = args;
36696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36697 if (!SWIG_IsOK(res1)) {
36698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
36699 }
36700 arg1 = reinterpret_cast< wxWindow * >(argp1);
36701 {
36702 PyThreadState* __tstate = wxPyBeginAllowThreads();
36703 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
36704 wxPyEndAllowThreads(__tstate);
36705 if (PyErr_Occurred()) SWIG_fail;
36706 }
36707 {
36708 resultobj = wxPyMake_wxObject(result, 0);
36709 }
36710 return resultobj;
36711 fail:
36712 return NULL;
36713 }
36714
36715
36716 SWIGINTERN PyObject *_wrap_Window_GetTopLevelParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36717 PyObject *resultobj = 0;
36718 wxWindow *arg1 = (wxWindow *) 0 ;
36719 wxWindow *result = 0 ;
36720 void *argp1 = 0 ;
36721 int res1 = 0 ;
36722 PyObject *swig_obj[1] ;
36723
36724 if (!args) SWIG_fail;
36725 swig_obj[0] = args;
36726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36727 if (!SWIG_IsOK(res1)) {
36728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTopLevelParent" "', expected argument " "1"" of type '" "wxWindow *""'");
36729 }
36730 arg1 = reinterpret_cast< wxWindow * >(argp1);
36731 {
36732 PyThreadState* __tstate = wxPyBeginAllowThreads();
36733 result = (wxWindow *)wxWindow_GetTopLevelParent(arg1);
36734 wxPyEndAllowThreads(__tstate);
36735 if (PyErr_Occurred()) SWIG_fail;
36736 }
36737 {
36738 resultobj = wxPyMake_wxObject(result, 0);
36739 }
36740 return resultobj;
36741 fail:
36742 return NULL;
36743 }
36744
36745
36746 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36747 PyObject *resultobj = 0;
36748 wxWindow *arg1 = (wxWindow *) 0 ;
36749 bool result;
36750 void *argp1 = 0 ;
36751 int res1 = 0 ;
36752 PyObject *swig_obj[1] ;
36753
36754 if (!args) SWIG_fail;
36755 swig_obj[0] = args;
36756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36757 if (!SWIG_IsOK(res1)) {
36758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
36759 }
36760 arg1 = reinterpret_cast< wxWindow * >(argp1);
36761 {
36762 PyThreadState* __tstate = wxPyBeginAllowThreads();
36763 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
36764 wxPyEndAllowThreads(__tstate);
36765 if (PyErr_Occurred()) SWIG_fail;
36766 }
36767 {
36768 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36769 }
36770 return resultobj;
36771 fail:
36772 return NULL;
36773 }
36774
36775
36776 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36777 PyObject *resultobj = 0;
36778 wxWindow *arg1 = (wxWindow *) 0 ;
36779 wxWindow *arg2 = (wxWindow *) 0 ;
36780 bool result;
36781 void *argp1 = 0 ;
36782 int res1 = 0 ;
36783 void *argp2 = 0 ;
36784 int res2 = 0 ;
36785 PyObject * obj0 = 0 ;
36786 PyObject * obj1 = 0 ;
36787 char * kwnames[] = {
36788 (char *) "self",(char *) "newParent", NULL
36789 };
36790
36791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
36792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36793 if (!SWIG_IsOK(res1)) {
36794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
36795 }
36796 arg1 = reinterpret_cast< wxWindow * >(argp1);
36797 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36798 if (!SWIG_IsOK(res2)) {
36799 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
36800 }
36801 arg2 = reinterpret_cast< wxWindow * >(argp2);
36802 {
36803 PyThreadState* __tstate = wxPyBeginAllowThreads();
36804 result = (bool)(arg1)->Reparent(arg2);
36805 wxPyEndAllowThreads(__tstate);
36806 if (PyErr_Occurred()) SWIG_fail;
36807 }
36808 {
36809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36810 }
36811 return resultobj;
36812 fail:
36813 return NULL;
36814 }
36815
36816
36817 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36818 PyObject *resultobj = 0;
36819 wxWindow *arg1 = (wxWindow *) 0 ;
36820 wxWindow *arg2 = (wxWindow *) 0 ;
36821 void *argp1 = 0 ;
36822 int res1 = 0 ;
36823 void *argp2 = 0 ;
36824 int res2 = 0 ;
36825 PyObject * obj0 = 0 ;
36826 PyObject * obj1 = 0 ;
36827 char * kwnames[] = {
36828 (char *) "self",(char *) "child", NULL
36829 };
36830
36831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
36832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36833 if (!SWIG_IsOK(res1)) {
36834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
36835 }
36836 arg1 = reinterpret_cast< wxWindow * >(argp1);
36837 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36838 if (!SWIG_IsOK(res2)) {
36839 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
36840 }
36841 arg2 = reinterpret_cast< wxWindow * >(argp2);
36842 {
36843 PyThreadState* __tstate = wxPyBeginAllowThreads();
36844 (arg1)->AddChild(arg2);
36845 wxPyEndAllowThreads(__tstate);
36846 if (PyErr_Occurred()) SWIG_fail;
36847 }
36848 resultobj = SWIG_Py_Void();
36849 return resultobj;
36850 fail:
36851 return NULL;
36852 }
36853
36854
36855 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36856 PyObject *resultobj = 0;
36857 wxWindow *arg1 = (wxWindow *) 0 ;
36858 wxWindow *arg2 = (wxWindow *) 0 ;
36859 void *argp1 = 0 ;
36860 int res1 = 0 ;
36861 void *argp2 = 0 ;
36862 int res2 = 0 ;
36863 PyObject * obj0 = 0 ;
36864 PyObject * obj1 = 0 ;
36865 char * kwnames[] = {
36866 (char *) "self",(char *) "child", NULL
36867 };
36868
36869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
36870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36871 if (!SWIG_IsOK(res1)) {
36872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
36873 }
36874 arg1 = reinterpret_cast< wxWindow * >(argp1);
36875 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36876 if (!SWIG_IsOK(res2)) {
36877 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
36878 }
36879 arg2 = reinterpret_cast< wxWindow * >(argp2);
36880 {
36881 PyThreadState* __tstate = wxPyBeginAllowThreads();
36882 (arg1)->RemoveChild(arg2);
36883 wxPyEndAllowThreads(__tstate);
36884 if (PyErr_Occurred()) SWIG_fail;
36885 }
36886 resultobj = SWIG_Py_Void();
36887 return resultobj;
36888 fail:
36889 return NULL;
36890 }
36891
36892
36893 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36894 PyObject *resultobj = 0;
36895 wxWindow *arg1 = (wxWindow *) 0 ;
36896 bool arg2 ;
36897 void *argp1 = 0 ;
36898 int res1 = 0 ;
36899 bool val2 ;
36900 int ecode2 = 0 ;
36901 PyObject * obj0 = 0 ;
36902 PyObject * obj1 = 0 ;
36903 char * kwnames[] = {
36904 (char *) "self",(char *) "on", NULL
36905 };
36906
36907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
36908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36909 if (!SWIG_IsOK(res1)) {
36910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
36911 }
36912 arg1 = reinterpret_cast< wxWindow * >(argp1);
36913 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36914 if (!SWIG_IsOK(ecode2)) {
36915 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
36916 }
36917 arg2 = static_cast< bool >(val2);
36918 {
36919 PyThreadState* __tstate = wxPyBeginAllowThreads();
36920 wxWindow_SetDoubleBuffered(arg1,arg2);
36921 wxPyEndAllowThreads(__tstate);
36922 if (PyErr_Occurred()) SWIG_fail;
36923 }
36924 resultobj = SWIG_Py_Void();
36925 return resultobj;
36926 fail:
36927 return NULL;
36928 }
36929
36930
36931 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36932 PyObject *resultobj = 0;
36933 wxWindow *arg1 = (wxWindow *) 0 ;
36934 long arg2 ;
36935 wxWindow *result = 0 ;
36936 void *argp1 = 0 ;
36937 int res1 = 0 ;
36938 long val2 ;
36939 int ecode2 = 0 ;
36940 PyObject * obj0 = 0 ;
36941 PyObject * obj1 = 0 ;
36942 char * kwnames[] = {
36943 (char *) "self",(char *) "winid", NULL
36944 };
36945
36946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
36947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36948 if (!SWIG_IsOK(res1)) {
36949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
36950 }
36951 arg1 = reinterpret_cast< wxWindow * >(argp1);
36952 ecode2 = SWIG_AsVal_long(obj1, &val2);
36953 if (!SWIG_IsOK(ecode2)) {
36954 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
36955 }
36956 arg2 = static_cast< long >(val2);
36957 {
36958 PyThreadState* __tstate = wxPyBeginAllowThreads();
36959 result = (wxWindow *)(arg1)->FindWindow(arg2);
36960 wxPyEndAllowThreads(__tstate);
36961 if (PyErr_Occurred()) SWIG_fail;
36962 }
36963 {
36964 resultobj = wxPyMake_wxObject(result, 0);
36965 }
36966 return resultobj;
36967 fail:
36968 return NULL;
36969 }
36970
36971
36972 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36973 PyObject *resultobj = 0;
36974 wxWindow *arg1 = (wxWindow *) 0 ;
36975 wxString *arg2 = 0 ;
36976 wxWindow *result = 0 ;
36977 void *argp1 = 0 ;
36978 int res1 = 0 ;
36979 bool temp2 = false ;
36980 PyObject * obj0 = 0 ;
36981 PyObject * obj1 = 0 ;
36982 char * kwnames[] = {
36983 (char *) "self",(char *) "name", NULL
36984 };
36985
36986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",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_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
36990 }
36991 arg1 = reinterpret_cast< wxWindow * >(argp1);
36992 {
36993 arg2 = wxString_in_helper(obj1);
36994 if (arg2 == NULL) SWIG_fail;
36995 temp2 = true;
36996 }
36997 {
36998 PyThreadState* __tstate = wxPyBeginAllowThreads();
36999 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
37000 wxPyEndAllowThreads(__tstate);
37001 if (PyErr_Occurred()) SWIG_fail;
37002 }
37003 {
37004 resultobj = wxPyMake_wxObject(result, 0);
37005 }
37006 {
37007 if (temp2)
37008 delete arg2;
37009 }
37010 return resultobj;
37011 fail:
37012 {
37013 if (temp2)
37014 delete arg2;
37015 }
37016 return NULL;
37017 }
37018
37019
37020 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37021 PyObject *resultobj = 0;
37022 wxWindow *arg1 = (wxWindow *) 0 ;
37023 wxEvtHandler *result = 0 ;
37024 void *argp1 = 0 ;
37025 int res1 = 0 ;
37026 PyObject *swig_obj[1] ;
37027
37028 if (!args) SWIG_fail;
37029 swig_obj[0] = args;
37030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37031 if (!SWIG_IsOK(res1)) {
37032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
37033 }
37034 arg1 = reinterpret_cast< wxWindow * >(argp1);
37035 {
37036 PyThreadState* __tstate = wxPyBeginAllowThreads();
37037 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
37038 wxPyEndAllowThreads(__tstate);
37039 if (PyErr_Occurred()) SWIG_fail;
37040 }
37041 {
37042 resultobj = wxPyMake_wxObject(result, 0);
37043 }
37044 return resultobj;
37045 fail:
37046 return NULL;
37047 }
37048
37049
37050 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37051 PyObject *resultobj = 0;
37052 wxWindow *arg1 = (wxWindow *) 0 ;
37053 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
37054 void *argp1 = 0 ;
37055 int res1 = 0 ;
37056 void *argp2 = 0 ;
37057 int res2 = 0 ;
37058 PyObject * obj0 = 0 ;
37059 PyObject * obj1 = 0 ;
37060 char * kwnames[] = {
37061 (char *) "self",(char *) "handler", NULL
37062 };
37063
37064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
37065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37066 if (!SWIG_IsOK(res1)) {
37067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
37068 }
37069 arg1 = reinterpret_cast< wxWindow * >(argp1);
37070 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
37071 if (!SWIG_IsOK(res2)) {
37072 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
37073 }
37074 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
37075 {
37076 PyThreadState* __tstate = wxPyBeginAllowThreads();
37077 (arg1)->SetEventHandler(arg2);
37078 wxPyEndAllowThreads(__tstate);
37079 if (PyErr_Occurred()) SWIG_fail;
37080 }
37081 resultobj = SWIG_Py_Void();
37082 return resultobj;
37083 fail:
37084 return NULL;
37085 }
37086
37087
37088 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37089 PyObject *resultobj = 0;
37090 wxWindow *arg1 = (wxWindow *) 0 ;
37091 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
37092 void *argp1 = 0 ;
37093 int res1 = 0 ;
37094 void *argp2 = 0 ;
37095 int res2 = 0 ;
37096 PyObject * obj0 = 0 ;
37097 PyObject * obj1 = 0 ;
37098 char * kwnames[] = {
37099 (char *) "self",(char *) "handler", NULL
37100 };
37101
37102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
37103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37104 if (!SWIG_IsOK(res1)) {
37105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
37106 }
37107 arg1 = reinterpret_cast< wxWindow * >(argp1);
37108 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
37109 if (!SWIG_IsOK(res2)) {
37110 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
37111 }
37112 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
37113 {
37114 PyThreadState* __tstate = wxPyBeginAllowThreads();
37115 (arg1)->PushEventHandler(arg2);
37116 wxPyEndAllowThreads(__tstate);
37117 if (PyErr_Occurred()) SWIG_fail;
37118 }
37119 resultobj = SWIG_Py_Void();
37120 return resultobj;
37121 fail:
37122 return NULL;
37123 }
37124
37125
37126 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37127 PyObject *resultobj = 0;
37128 wxWindow *arg1 = (wxWindow *) 0 ;
37129 bool arg2 = (bool) false ;
37130 wxEvtHandler *result = 0 ;
37131 void *argp1 = 0 ;
37132 int res1 = 0 ;
37133 bool val2 ;
37134 int ecode2 = 0 ;
37135 PyObject * obj0 = 0 ;
37136 PyObject * obj1 = 0 ;
37137 char * kwnames[] = {
37138 (char *) "self",(char *) "deleteHandler", NULL
37139 };
37140
37141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
37142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37143 if (!SWIG_IsOK(res1)) {
37144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
37145 }
37146 arg1 = reinterpret_cast< wxWindow * >(argp1);
37147 if (obj1) {
37148 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37149 if (!SWIG_IsOK(ecode2)) {
37150 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
37151 }
37152 arg2 = static_cast< bool >(val2);
37153 }
37154 {
37155 PyThreadState* __tstate = wxPyBeginAllowThreads();
37156 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
37157 wxPyEndAllowThreads(__tstate);
37158 if (PyErr_Occurred()) SWIG_fail;
37159 }
37160 {
37161 resultobj = wxPyMake_wxObject(result, 0);
37162 }
37163 return resultobj;
37164 fail:
37165 return NULL;
37166 }
37167
37168
37169 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37170 PyObject *resultobj = 0;
37171 wxWindow *arg1 = (wxWindow *) 0 ;
37172 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
37173 bool result;
37174 void *argp1 = 0 ;
37175 int res1 = 0 ;
37176 void *argp2 = 0 ;
37177 int res2 = 0 ;
37178 PyObject * obj0 = 0 ;
37179 PyObject * obj1 = 0 ;
37180 char * kwnames[] = {
37181 (char *) "self",(char *) "handler", NULL
37182 };
37183
37184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
37185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37186 if (!SWIG_IsOK(res1)) {
37187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
37188 }
37189 arg1 = reinterpret_cast< wxWindow * >(argp1);
37190 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
37191 if (!SWIG_IsOK(res2)) {
37192 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
37193 }
37194 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
37195 {
37196 PyThreadState* __tstate = wxPyBeginAllowThreads();
37197 result = (bool)(arg1)->RemoveEventHandler(arg2);
37198 wxPyEndAllowThreads(__tstate);
37199 if (PyErr_Occurred()) SWIG_fail;
37200 }
37201 {
37202 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37203 }
37204 return resultobj;
37205 fail:
37206 return NULL;
37207 }
37208
37209
37210 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37211 PyObject *resultobj = 0;
37212 wxWindow *arg1 = (wxWindow *) 0 ;
37213 wxValidator *arg2 = 0 ;
37214 void *argp1 = 0 ;
37215 int res1 = 0 ;
37216 void *argp2 = 0 ;
37217 int res2 = 0 ;
37218 PyObject * obj0 = 0 ;
37219 PyObject * obj1 = 0 ;
37220 char * kwnames[] = {
37221 (char *) "self",(char *) "validator", NULL
37222 };
37223
37224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
37225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37226 if (!SWIG_IsOK(res1)) {
37227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
37228 }
37229 arg1 = reinterpret_cast< wxWindow * >(argp1);
37230 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
37231 if (!SWIG_IsOK(res2)) {
37232 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
37233 }
37234 if (!argp2) {
37235 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
37236 }
37237 arg2 = reinterpret_cast< wxValidator * >(argp2);
37238 {
37239 PyThreadState* __tstate = wxPyBeginAllowThreads();
37240 (arg1)->SetValidator((wxValidator const &)*arg2);
37241 wxPyEndAllowThreads(__tstate);
37242 if (PyErr_Occurred()) SWIG_fail;
37243 }
37244 resultobj = SWIG_Py_Void();
37245 return resultobj;
37246 fail:
37247 return NULL;
37248 }
37249
37250
37251 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37252 PyObject *resultobj = 0;
37253 wxWindow *arg1 = (wxWindow *) 0 ;
37254 wxValidator *result = 0 ;
37255 void *argp1 = 0 ;
37256 int res1 = 0 ;
37257 PyObject *swig_obj[1] ;
37258
37259 if (!args) SWIG_fail;
37260 swig_obj[0] = args;
37261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37262 if (!SWIG_IsOK(res1)) {
37263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
37264 }
37265 arg1 = reinterpret_cast< wxWindow * >(argp1);
37266 {
37267 PyThreadState* __tstate = wxPyBeginAllowThreads();
37268 result = (wxValidator *)(arg1)->GetValidator();
37269 wxPyEndAllowThreads(__tstate);
37270 if (PyErr_Occurred()) SWIG_fail;
37271 }
37272 {
37273 resultobj = wxPyMake_wxObject(result, (bool)0);
37274 }
37275 return resultobj;
37276 fail:
37277 return NULL;
37278 }
37279
37280
37281 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37282 PyObject *resultobj = 0;
37283 wxWindow *arg1 = (wxWindow *) 0 ;
37284 bool result;
37285 void *argp1 = 0 ;
37286 int res1 = 0 ;
37287 PyObject *swig_obj[1] ;
37288
37289 if (!args) SWIG_fail;
37290 swig_obj[0] = args;
37291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37292 if (!SWIG_IsOK(res1)) {
37293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
37294 }
37295 arg1 = reinterpret_cast< wxWindow * >(argp1);
37296 {
37297 PyThreadState* __tstate = wxPyBeginAllowThreads();
37298 result = (bool)(arg1)->Validate();
37299 wxPyEndAllowThreads(__tstate);
37300 if (PyErr_Occurred()) SWIG_fail;
37301 }
37302 {
37303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37304 }
37305 return resultobj;
37306 fail:
37307 return NULL;
37308 }
37309
37310
37311 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37312 PyObject *resultobj = 0;
37313 wxWindow *arg1 = (wxWindow *) 0 ;
37314 bool result;
37315 void *argp1 = 0 ;
37316 int res1 = 0 ;
37317 PyObject *swig_obj[1] ;
37318
37319 if (!args) SWIG_fail;
37320 swig_obj[0] = args;
37321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37322 if (!SWIG_IsOK(res1)) {
37323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
37324 }
37325 arg1 = reinterpret_cast< wxWindow * >(argp1);
37326 {
37327 PyThreadState* __tstate = wxPyBeginAllowThreads();
37328 result = (bool)(arg1)->TransferDataToWindow();
37329 wxPyEndAllowThreads(__tstate);
37330 if (PyErr_Occurred()) SWIG_fail;
37331 }
37332 {
37333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37334 }
37335 return resultobj;
37336 fail:
37337 return NULL;
37338 }
37339
37340
37341 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37342 PyObject *resultobj = 0;
37343 wxWindow *arg1 = (wxWindow *) 0 ;
37344 bool result;
37345 void *argp1 = 0 ;
37346 int res1 = 0 ;
37347 PyObject *swig_obj[1] ;
37348
37349 if (!args) SWIG_fail;
37350 swig_obj[0] = args;
37351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37352 if (!SWIG_IsOK(res1)) {
37353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
37354 }
37355 arg1 = reinterpret_cast< wxWindow * >(argp1);
37356 {
37357 PyThreadState* __tstate = wxPyBeginAllowThreads();
37358 result = (bool)(arg1)->TransferDataFromWindow();
37359 wxPyEndAllowThreads(__tstate);
37360 if (PyErr_Occurred()) SWIG_fail;
37361 }
37362 {
37363 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37364 }
37365 return resultobj;
37366 fail:
37367 return NULL;
37368 }
37369
37370
37371 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37372 PyObject *resultobj = 0;
37373 wxWindow *arg1 = (wxWindow *) 0 ;
37374 void *argp1 = 0 ;
37375 int res1 = 0 ;
37376 PyObject *swig_obj[1] ;
37377
37378 if (!args) SWIG_fail;
37379 swig_obj[0] = args;
37380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37381 if (!SWIG_IsOK(res1)) {
37382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37383 }
37384 arg1 = reinterpret_cast< wxWindow * >(argp1);
37385 {
37386 PyThreadState* __tstate = wxPyBeginAllowThreads();
37387 (arg1)->InitDialog();
37388 wxPyEndAllowThreads(__tstate);
37389 if (PyErr_Occurred()) SWIG_fail;
37390 }
37391 resultobj = SWIG_Py_Void();
37392 return resultobj;
37393 fail:
37394 return NULL;
37395 }
37396
37397
37398 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37399 PyObject *resultobj = 0;
37400 wxWindow *arg1 = (wxWindow *) 0 ;
37401 wxAcceleratorTable *arg2 = 0 ;
37402 void *argp1 = 0 ;
37403 int res1 = 0 ;
37404 void *argp2 = 0 ;
37405 int res2 = 0 ;
37406 PyObject * obj0 = 0 ;
37407 PyObject * obj1 = 0 ;
37408 char * kwnames[] = {
37409 (char *) "self",(char *) "accel", NULL
37410 };
37411
37412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
37413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37414 if (!SWIG_IsOK(res1)) {
37415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37416 }
37417 arg1 = reinterpret_cast< wxWindow * >(argp1);
37418 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
37419 if (!SWIG_IsOK(res2)) {
37420 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
37421 }
37422 if (!argp2) {
37423 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
37424 }
37425 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
37426 {
37427 PyThreadState* __tstate = wxPyBeginAllowThreads();
37428 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
37429 wxPyEndAllowThreads(__tstate);
37430 if (PyErr_Occurred()) SWIG_fail;
37431 }
37432 resultobj = SWIG_Py_Void();
37433 return resultobj;
37434 fail:
37435 return NULL;
37436 }
37437
37438
37439 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37440 PyObject *resultobj = 0;
37441 wxWindow *arg1 = (wxWindow *) 0 ;
37442 wxAcceleratorTable *result = 0 ;
37443 void *argp1 = 0 ;
37444 int res1 = 0 ;
37445 PyObject *swig_obj[1] ;
37446
37447 if (!args) SWIG_fail;
37448 swig_obj[0] = args;
37449 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37450 if (!SWIG_IsOK(res1)) {
37451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37452 }
37453 arg1 = reinterpret_cast< wxWindow * >(argp1);
37454 {
37455 PyThreadState* __tstate = wxPyBeginAllowThreads();
37456 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
37457 wxPyEndAllowThreads(__tstate);
37458 if (PyErr_Occurred()) SWIG_fail;
37459 }
37460 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
37461 return resultobj;
37462 fail:
37463 return NULL;
37464 }
37465
37466
37467 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37468 PyObject *resultobj = 0;
37469 wxWindow *arg1 = (wxWindow *) 0 ;
37470 int arg2 ;
37471 int arg3 ;
37472 int arg4 ;
37473 bool result;
37474 void *argp1 = 0 ;
37475 int res1 = 0 ;
37476 int val2 ;
37477 int ecode2 = 0 ;
37478 int val3 ;
37479 int ecode3 = 0 ;
37480 int val4 ;
37481 int ecode4 = 0 ;
37482 PyObject * obj0 = 0 ;
37483 PyObject * obj1 = 0 ;
37484 PyObject * obj2 = 0 ;
37485 PyObject * obj3 = 0 ;
37486 char * kwnames[] = {
37487 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
37488 };
37489
37490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37492 if (!SWIG_IsOK(res1)) {
37493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
37494 }
37495 arg1 = reinterpret_cast< wxWindow * >(argp1);
37496 ecode2 = SWIG_AsVal_int(obj1, &val2);
37497 if (!SWIG_IsOK(ecode2)) {
37498 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
37499 }
37500 arg2 = static_cast< int >(val2);
37501 ecode3 = SWIG_AsVal_int(obj2, &val3);
37502 if (!SWIG_IsOK(ecode3)) {
37503 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
37504 }
37505 arg3 = static_cast< int >(val3);
37506 ecode4 = SWIG_AsVal_int(obj3, &val4);
37507 if (!SWIG_IsOK(ecode4)) {
37508 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
37509 }
37510 arg4 = static_cast< int >(val4);
37511 {
37512 PyThreadState* __tstate = wxPyBeginAllowThreads();
37513 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
37514 wxPyEndAllowThreads(__tstate);
37515 if (PyErr_Occurred()) SWIG_fail;
37516 }
37517 {
37518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37519 }
37520 return resultobj;
37521 fail:
37522 return NULL;
37523 }
37524
37525
37526 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37527 PyObject *resultobj = 0;
37528 wxWindow *arg1 = (wxWindow *) 0 ;
37529 int arg2 ;
37530 bool result;
37531 void *argp1 = 0 ;
37532 int res1 = 0 ;
37533 int val2 ;
37534 int ecode2 = 0 ;
37535 PyObject * obj0 = 0 ;
37536 PyObject * obj1 = 0 ;
37537 char * kwnames[] = {
37538 (char *) "self",(char *) "hotkeyId", NULL
37539 };
37540
37541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
37542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37543 if (!SWIG_IsOK(res1)) {
37544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
37545 }
37546 arg1 = reinterpret_cast< wxWindow * >(argp1);
37547 ecode2 = SWIG_AsVal_int(obj1, &val2);
37548 if (!SWIG_IsOK(ecode2)) {
37549 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
37550 }
37551 arg2 = static_cast< int >(val2);
37552 {
37553 PyThreadState* __tstate = wxPyBeginAllowThreads();
37554 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
37555 wxPyEndAllowThreads(__tstate);
37556 if (PyErr_Occurred()) SWIG_fail;
37557 }
37558 {
37559 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37560 }
37561 return resultobj;
37562 fail:
37563 return NULL;
37564 }
37565
37566
37567 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37568 PyObject *resultobj = 0;
37569 wxWindow *arg1 = (wxWindow *) 0 ;
37570 wxPoint *arg2 = 0 ;
37571 wxPoint result;
37572 void *argp1 = 0 ;
37573 int res1 = 0 ;
37574 wxPoint temp2 ;
37575 PyObject * obj0 = 0 ;
37576 PyObject * obj1 = 0 ;
37577 char * kwnames[] = {
37578 (char *) "self",(char *) "pt", NULL
37579 };
37580
37581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
37582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37583 if (!SWIG_IsOK(res1)) {
37584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
37585 }
37586 arg1 = reinterpret_cast< wxWindow * >(argp1);
37587 {
37588 arg2 = &temp2;
37589 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37590 }
37591 {
37592 PyThreadState* __tstate = wxPyBeginAllowThreads();
37593 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
37594 wxPyEndAllowThreads(__tstate);
37595 if (PyErr_Occurred()) SWIG_fail;
37596 }
37597 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37598 return resultobj;
37599 fail:
37600 return NULL;
37601 }
37602
37603
37604 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37605 PyObject *resultobj = 0;
37606 wxWindow *arg1 = (wxWindow *) 0 ;
37607 wxSize *arg2 = 0 ;
37608 wxSize result;
37609 void *argp1 = 0 ;
37610 int res1 = 0 ;
37611 wxSize temp2 ;
37612 PyObject * obj0 = 0 ;
37613 PyObject * obj1 = 0 ;
37614 char * kwnames[] = {
37615 (char *) "self",(char *) "sz", NULL
37616 };
37617
37618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
37619 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37620 if (!SWIG_IsOK(res1)) {
37621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
37622 }
37623 arg1 = reinterpret_cast< wxWindow * >(argp1);
37624 {
37625 arg2 = &temp2;
37626 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37627 }
37628 {
37629 PyThreadState* __tstate = wxPyBeginAllowThreads();
37630 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
37631 wxPyEndAllowThreads(__tstate);
37632 if (PyErr_Occurred()) SWIG_fail;
37633 }
37634 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37635 return resultobj;
37636 fail:
37637 return NULL;
37638 }
37639
37640
37641 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37642 PyObject *resultobj = 0;
37643 wxWindow *arg1 = (wxWindow *) 0 ;
37644 wxPoint *arg2 = 0 ;
37645 wxPoint result;
37646 void *argp1 = 0 ;
37647 int res1 = 0 ;
37648 wxPoint temp2 ;
37649 PyObject * obj0 = 0 ;
37650 PyObject * obj1 = 0 ;
37651 char * kwnames[] = {
37652 (char *) "self",(char *) "pt", NULL
37653 };
37654
37655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
37656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37657 if (!SWIG_IsOK(res1)) {
37658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
37659 }
37660 arg1 = reinterpret_cast< wxWindow * >(argp1);
37661 {
37662 arg2 = &temp2;
37663 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37664 }
37665 {
37666 PyThreadState* __tstate = wxPyBeginAllowThreads();
37667 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
37668 wxPyEndAllowThreads(__tstate);
37669 if (PyErr_Occurred()) SWIG_fail;
37670 }
37671 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37672 return resultobj;
37673 fail:
37674 return NULL;
37675 }
37676
37677
37678 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37679 PyObject *resultobj = 0;
37680 wxWindow *arg1 = (wxWindow *) 0 ;
37681 wxSize *arg2 = 0 ;
37682 wxSize result;
37683 void *argp1 = 0 ;
37684 int res1 = 0 ;
37685 wxSize temp2 ;
37686 PyObject * obj0 = 0 ;
37687 PyObject * obj1 = 0 ;
37688 char * kwnames[] = {
37689 (char *) "self",(char *) "sz", NULL
37690 };
37691
37692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
37693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37694 if (!SWIG_IsOK(res1)) {
37695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
37696 }
37697 arg1 = reinterpret_cast< wxWindow * >(argp1);
37698 {
37699 arg2 = &temp2;
37700 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37701 }
37702 {
37703 PyThreadState* __tstate = wxPyBeginAllowThreads();
37704 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
37705 wxPyEndAllowThreads(__tstate);
37706 if (PyErr_Occurred()) SWIG_fail;
37707 }
37708 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37709 return resultobj;
37710 fail:
37711 return NULL;
37712 }
37713
37714
37715 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37716 PyObject *resultobj = 0;
37717 wxWindow *arg1 = (wxWindow *) 0 ;
37718 wxPoint *arg2 = 0 ;
37719 wxPoint result;
37720 void *argp1 = 0 ;
37721 int res1 = 0 ;
37722 wxPoint temp2 ;
37723 PyObject * obj0 = 0 ;
37724 PyObject * obj1 = 0 ;
37725 char * kwnames[] = {
37726 (char *) "self",(char *) "pt", NULL
37727 };
37728
37729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
37730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37731 if (!SWIG_IsOK(res1)) {
37732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37733 }
37734 arg1 = reinterpret_cast< wxWindow * >(argp1);
37735 {
37736 arg2 = &temp2;
37737 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37738 }
37739 {
37740 PyThreadState* __tstate = wxPyBeginAllowThreads();
37741 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
37742 wxPyEndAllowThreads(__tstate);
37743 if (PyErr_Occurred()) SWIG_fail;
37744 }
37745 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37746 return resultobj;
37747 fail:
37748 return NULL;
37749 }
37750
37751
37752 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37753 PyObject *resultobj = 0;
37754 wxWindow *arg1 = (wxWindow *) 0 ;
37755 wxSize *arg2 = 0 ;
37756 wxSize result;
37757 void *argp1 = 0 ;
37758 int res1 = 0 ;
37759 wxSize temp2 ;
37760 PyObject * obj0 = 0 ;
37761 PyObject * obj1 = 0 ;
37762 char * kwnames[] = {
37763 (char *) "self",(char *) "sz", NULL
37764 };
37765
37766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
37767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37768 if (!SWIG_IsOK(res1)) {
37769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37770 }
37771 arg1 = reinterpret_cast< wxWindow * >(argp1);
37772 {
37773 arg2 = &temp2;
37774 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37775 }
37776 {
37777 PyThreadState* __tstate = wxPyBeginAllowThreads();
37778 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
37779 wxPyEndAllowThreads(__tstate);
37780 if (PyErr_Occurred()) SWIG_fail;
37781 }
37782 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37783 return resultobj;
37784 fail:
37785 return NULL;
37786 }
37787
37788
37789 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37790 PyObject *resultobj = 0;
37791 wxWindow *arg1 = (wxWindow *) 0 ;
37792 int arg2 ;
37793 int arg3 ;
37794 void *argp1 = 0 ;
37795 int res1 = 0 ;
37796 int val2 ;
37797 int ecode2 = 0 ;
37798 int val3 ;
37799 int ecode3 = 0 ;
37800 PyObject * obj0 = 0 ;
37801 PyObject * obj1 = 0 ;
37802 PyObject * obj2 = 0 ;
37803 char * kwnames[] = {
37804 (char *) "self",(char *) "x",(char *) "y", NULL
37805 };
37806
37807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37809 if (!SWIG_IsOK(res1)) {
37810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
37811 }
37812 arg1 = reinterpret_cast< wxWindow * >(argp1);
37813 ecode2 = SWIG_AsVal_int(obj1, &val2);
37814 if (!SWIG_IsOK(ecode2)) {
37815 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
37816 }
37817 arg2 = static_cast< int >(val2);
37818 ecode3 = SWIG_AsVal_int(obj2, &val3);
37819 if (!SWIG_IsOK(ecode3)) {
37820 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
37821 }
37822 arg3 = static_cast< int >(val3);
37823 {
37824 PyThreadState* __tstate = wxPyBeginAllowThreads();
37825 (arg1)->WarpPointer(arg2,arg3);
37826 wxPyEndAllowThreads(__tstate);
37827 if (PyErr_Occurred()) SWIG_fail;
37828 }
37829 resultobj = SWIG_Py_Void();
37830 return resultobj;
37831 fail:
37832 return NULL;
37833 }
37834
37835
37836 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37837 PyObject *resultobj = 0;
37838 wxWindow *arg1 = (wxWindow *) 0 ;
37839 void *argp1 = 0 ;
37840 int res1 = 0 ;
37841 PyObject *swig_obj[1] ;
37842
37843 if (!args) SWIG_fail;
37844 swig_obj[0] = args;
37845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37846 if (!SWIG_IsOK(res1)) {
37847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
37848 }
37849 arg1 = reinterpret_cast< wxWindow * >(argp1);
37850 {
37851 PyThreadState* __tstate = wxPyBeginAllowThreads();
37852 (arg1)->CaptureMouse();
37853 wxPyEndAllowThreads(__tstate);
37854 if (PyErr_Occurred()) SWIG_fail;
37855 }
37856 resultobj = SWIG_Py_Void();
37857 return resultobj;
37858 fail:
37859 return NULL;
37860 }
37861
37862
37863 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37864 PyObject *resultobj = 0;
37865 wxWindow *arg1 = (wxWindow *) 0 ;
37866 void *argp1 = 0 ;
37867 int res1 = 0 ;
37868 PyObject *swig_obj[1] ;
37869
37870 if (!args) SWIG_fail;
37871 swig_obj[0] = args;
37872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37873 if (!SWIG_IsOK(res1)) {
37874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
37875 }
37876 arg1 = reinterpret_cast< wxWindow * >(argp1);
37877 {
37878 PyThreadState* __tstate = wxPyBeginAllowThreads();
37879 (arg1)->ReleaseMouse();
37880 wxPyEndAllowThreads(__tstate);
37881 if (PyErr_Occurred()) SWIG_fail;
37882 }
37883 resultobj = SWIG_Py_Void();
37884 return resultobj;
37885 fail:
37886 return NULL;
37887 }
37888
37889
37890 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37891 PyObject *resultobj = 0;
37892 wxWindow *result = 0 ;
37893
37894 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
37895 {
37896 if (!wxPyCheckForApp()) SWIG_fail;
37897 PyThreadState* __tstate = wxPyBeginAllowThreads();
37898 result = (wxWindow *)wxWindow::GetCapture();
37899 wxPyEndAllowThreads(__tstate);
37900 if (PyErr_Occurred()) SWIG_fail;
37901 }
37902 {
37903 resultobj = wxPyMake_wxObject(result, 0);
37904 }
37905 return resultobj;
37906 fail:
37907 return NULL;
37908 }
37909
37910
37911 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37912 PyObject *resultobj = 0;
37913 wxWindow *arg1 = (wxWindow *) 0 ;
37914 bool result;
37915 void *argp1 = 0 ;
37916 int res1 = 0 ;
37917 PyObject *swig_obj[1] ;
37918
37919 if (!args) SWIG_fail;
37920 swig_obj[0] = args;
37921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37922 if (!SWIG_IsOK(res1)) {
37923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
37924 }
37925 arg1 = reinterpret_cast< wxWindow * >(argp1);
37926 {
37927 PyThreadState* __tstate = wxPyBeginAllowThreads();
37928 result = (bool)((wxWindow const *)arg1)->HasCapture();
37929 wxPyEndAllowThreads(__tstate);
37930 if (PyErr_Occurred()) SWIG_fail;
37931 }
37932 {
37933 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37934 }
37935 return resultobj;
37936 fail:
37937 return NULL;
37938 }
37939
37940
37941 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37942 PyObject *resultobj = 0;
37943 wxWindow *arg1 = (wxWindow *) 0 ;
37944 bool arg2 = (bool) true ;
37945 wxRect *arg3 = (wxRect *) NULL ;
37946 void *argp1 = 0 ;
37947 int res1 = 0 ;
37948 bool val2 ;
37949 int ecode2 = 0 ;
37950 void *argp3 = 0 ;
37951 int res3 = 0 ;
37952 PyObject * obj0 = 0 ;
37953 PyObject * obj1 = 0 ;
37954 PyObject * obj2 = 0 ;
37955 char * kwnames[] = {
37956 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
37957 };
37958
37959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37961 if (!SWIG_IsOK(res1)) {
37962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
37963 }
37964 arg1 = reinterpret_cast< wxWindow * >(argp1);
37965 if (obj1) {
37966 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37967 if (!SWIG_IsOK(ecode2)) {
37968 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
37969 }
37970 arg2 = static_cast< bool >(val2);
37971 }
37972 if (obj2) {
37973 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
37974 if (!SWIG_IsOK(res3)) {
37975 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
37976 }
37977 arg3 = reinterpret_cast< wxRect * >(argp3);
37978 }
37979 {
37980 PyThreadState* __tstate = wxPyBeginAllowThreads();
37981 (arg1)->Refresh(arg2,(wxRect const *)arg3);
37982 wxPyEndAllowThreads(__tstate);
37983 if (PyErr_Occurred()) SWIG_fail;
37984 }
37985 resultobj = SWIG_Py_Void();
37986 return resultobj;
37987 fail:
37988 return NULL;
37989 }
37990
37991
37992 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37993 PyObject *resultobj = 0;
37994 wxWindow *arg1 = (wxWindow *) 0 ;
37995 wxRect *arg2 = 0 ;
37996 bool arg3 = (bool) true ;
37997 void *argp1 = 0 ;
37998 int res1 = 0 ;
37999 wxRect temp2 ;
38000 bool val3 ;
38001 int ecode3 = 0 ;
38002 PyObject * obj0 = 0 ;
38003 PyObject * obj1 = 0 ;
38004 PyObject * obj2 = 0 ;
38005 char * kwnames[] = {
38006 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
38007 };
38008
38009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38011 if (!SWIG_IsOK(res1)) {
38012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
38013 }
38014 arg1 = reinterpret_cast< wxWindow * >(argp1);
38015 {
38016 arg2 = &temp2;
38017 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
38018 }
38019 if (obj2) {
38020 ecode3 = SWIG_AsVal_bool(obj2, &val3);
38021 if (!SWIG_IsOK(ecode3)) {
38022 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
38023 }
38024 arg3 = static_cast< bool >(val3);
38025 }
38026 {
38027 PyThreadState* __tstate = wxPyBeginAllowThreads();
38028 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
38029 wxPyEndAllowThreads(__tstate);
38030 if (PyErr_Occurred()) SWIG_fail;
38031 }
38032 resultobj = SWIG_Py_Void();
38033 return resultobj;
38034 fail:
38035 return NULL;
38036 }
38037
38038
38039 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38040 PyObject *resultobj = 0;
38041 wxWindow *arg1 = (wxWindow *) 0 ;
38042 void *argp1 = 0 ;
38043 int res1 = 0 ;
38044 PyObject *swig_obj[1] ;
38045
38046 if (!args) SWIG_fail;
38047 swig_obj[0] = args;
38048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38049 if (!SWIG_IsOK(res1)) {
38050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
38051 }
38052 arg1 = reinterpret_cast< wxWindow * >(argp1);
38053 {
38054 PyThreadState* __tstate = wxPyBeginAllowThreads();
38055 (arg1)->Update();
38056 wxPyEndAllowThreads(__tstate);
38057 if (PyErr_Occurred()) SWIG_fail;
38058 }
38059 resultobj = SWIG_Py_Void();
38060 return resultobj;
38061 fail:
38062 return NULL;
38063 }
38064
38065
38066 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38067 PyObject *resultobj = 0;
38068 wxWindow *arg1 = (wxWindow *) 0 ;
38069 void *argp1 = 0 ;
38070 int res1 = 0 ;
38071 PyObject *swig_obj[1] ;
38072
38073 if (!args) SWIG_fail;
38074 swig_obj[0] = args;
38075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38076 if (!SWIG_IsOK(res1)) {
38077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
38078 }
38079 arg1 = reinterpret_cast< wxWindow * >(argp1);
38080 {
38081 PyThreadState* __tstate = wxPyBeginAllowThreads();
38082 (arg1)->ClearBackground();
38083 wxPyEndAllowThreads(__tstate);
38084 if (PyErr_Occurred()) SWIG_fail;
38085 }
38086 resultobj = SWIG_Py_Void();
38087 return resultobj;
38088 fail:
38089 return NULL;
38090 }
38091
38092
38093 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38094 PyObject *resultobj = 0;
38095 wxWindow *arg1 = (wxWindow *) 0 ;
38096 void *argp1 = 0 ;
38097 int res1 = 0 ;
38098 PyObject *swig_obj[1] ;
38099
38100 if (!args) SWIG_fail;
38101 swig_obj[0] = args;
38102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38103 if (!SWIG_IsOK(res1)) {
38104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
38105 }
38106 arg1 = reinterpret_cast< wxWindow * >(argp1);
38107 {
38108 PyThreadState* __tstate = wxPyBeginAllowThreads();
38109 (arg1)->Freeze();
38110 wxPyEndAllowThreads(__tstate);
38111 if (PyErr_Occurred()) SWIG_fail;
38112 }
38113 resultobj = SWIG_Py_Void();
38114 return resultobj;
38115 fail:
38116 return NULL;
38117 }
38118
38119
38120 SWIGINTERN PyObject *_wrap_Window_IsFrozen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38121 PyObject *resultobj = 0;
38122 wxWindow *arg1 = (wxWindow *) 0 ;
38123 bool result;
38124 void *argp1 = 0 ;
38125 int res1 = 0 ;
38126 PyObject *swig_obj[1] ;
38127
38128 if (!args) SWIG_fail;
38129 swig_obj[0] = args;
38130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38131 if (!SWIG_IsOK(res1)) {
38132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsFrozen" "', expected argument " "1"" of type '" "wxWindow const *""'");
38133 }
38134 arg1 = reinterpret_cast< wxWindow * >(argp1);
38135 {
38136 PyThreadState* __tstate = wxPyBeginAllowThreads();
38137 result = (bool)((wxWindow const *)arg1)->IsFrozen();
38138 wxPyEndAllowThreads(__tstate);
38139 if (PyErr_Occurred()) SWIG_fail;
38140 }
38141 {
38142 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38143 }
38144 return resultobj;
38145 fail:
38146 return NULL;
38147 }
38148
38149
38150 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38151 PyObject *resultobj = 0;
38152 wxWindow *arg1 = (wxWindow *) 0 ;
38153 void *argp1 = 0 ;
38154 int res1 = 0 ;
38155 PyObject *swig_obj[1] ;
38156
38157 if (!args) SWIG_fail;
38158 swig_obj[0] = args;
38159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38160 if (!SWIG_IsOK(res1)) {
38161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
38162 }
38163 arg1 = reinterpret_cast< wxWindow * >(argp1);
38164 {
38165 PyThreadState* __tstate = wxPyBeginAllowThreads();
38166 (arg1)->Thaw();
38167 wxPyEndAllowThreads(__tstate);
38168 if (PyErr_Occurred()) SWIG_fail;
38169 }
38170 resultobj = SWIG_Py_Void();
38171 return resultobj;
38172 fail:
38173 return NULL;
38174 }
38175
38176
38177 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38178 PyObject *resultobj = 0;
38179 wxWindow *arg1 = (wxWindow *) 0 ;
38180 wxDC *arg2 = 0 ;
38181 void *argp1 = 0 ;
38182 int res1 = 0 ;
38183 void *argp2 = 0 ;
38184 int res2 = 0 ;
38185 PyObject * obj0 = 0 ;
38186 PyObject * obj1 = 0 ;
38187 char * kwnames[] = {
38188 (char *) "self",(char *) "dc", NULL
38189 };
38190
38191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
38192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38193 if (!SWIG_IsOK(res1)) {
38194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
38195 }
38196 arg1 = reinterpret_cast< wxWindow * >(argp1);
38197 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
38198 if (!SWIG_IsOK(res2)) {
38199 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
38200 }
38201 if (!argp2) {
38202 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
38203 }
38204 arg2 = reinterpret_cast< wxDC * >(argp2);
38205 {
38206 PyThreadState* __tstate = wxPyBeginAllowThreads();
38207 (arg1)->PrepareDC(*arg2);
38208 wxPyEndAllowThreads(__tstate);
38209 if (PyErr_Occurred()) SWIG_fail;
38210 }
38211 resultobj = SWIG_Py_Void();
38212 return resultobj;
38213 fail:
38214 return NULL;
38215 }
38216
38217
38218 SWIGINTERN PyObject *_wrap_Window_IsDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38219 PyObject *resultobj = 0;
38220 wxWindow *arg1 = (wxWindow *) 0 ;
38221 bool result;
38222 void *argp1 = 0 ;
38223 int res1 = 0 ;
38224 PyObject *swig_obj[1] ;
38225
38226 if (!args) SWIG_fail;
38227 swig_obj[0] = args;
38228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38229 if (!SWIG_IsOK(res1)) {
38230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow const *""'");
38231 }
38232 arg1 = reinterpret_cast< wxWindow * >(argp1);
38233 {
38234 PyThreadState* __tstate = wxPyBeginAllowThreads();
38235 result = (bool)((wxWindow const *)arg1)->IsDoubleBuffered();
38236 wxPyEndAllowThreads(__tstate);
38237 if (PyErr_Occurred()) SWIG_fail;
38238 }
38239 {
38240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38241 }
38242 return resultobj;
38243 fail:
38244 return NULL;
38245 }
38246
38247
38248 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38249 PyObject *resultobj = 0;
38250 wxWindow *arg1 = (wxWindow *) 0 ;
38251 wxRegion *result = 0 ;
38252 void *argp1 = 0 ;
38253 int res1 = 0 ;
38254 PyObject *swig_obj[1] ;
38255
38256 if (!args) SWIG_fail;
38257 swig_obj[0] = args;
38258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38259 if (!SWIG_IsOK(res1)) {
38260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
38261 }
38262 arg1 = reinterpret_cast< wxWindow * >(argp1);
38263 {
38264 PyThreadState* __tstate = wxPyBeginAllowThreads();
38265 {
38266 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
38267 result = (wxRegion *) &_result_ref;
38268 }
38269 wxPyEndAllowThreads(__tstate);
38270 if (PyErr_Occurred()) SWIG_fail;
38271 }
38272 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
38273 return resultobj;
38274 fail:
38275 return NULL;
38276 }
38277
38278
38279 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38280 PyObject *resultobj = 0;
38281 wxWindow *arg1 = (wxWindow *) 0 ;
38282 wxRect result;
38283 void *argp1 = 0 ;
38284 int res1 = 0 ;
38285 PyObject *swig_obj[1] ;
38286
38287 if (!args) SWIG_fail;
38288 swig_obj[0] = args;
38289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38290 if (!SWIG_IsOK(res1)) {
38291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
38292 }
38293 arg1 = reinterpret_cast< wxWindow * >(argp1);
38294 {
38295 PyThreadState* __tstate = wxPyBeginAllowThreads();
38296 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
38297 wxPyEndAllowThreads(__tstate);
38298 if (PyErr_Occurred()) SWIG_fail;
38299 }
38300 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
38301 return resultobj;
38302 fail:
38303 return NULL;
38304 }
38305
38306
38307 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38308 PyObject *resultobj = 0;
38309 wxWindow *arg1 = (wxWindow *) 0 ;
38310 int arg2 ;
38311 int arg3 ;
38312 int arg4 = (int) 1 ;
38313 int arg5 = (int) 1 ;
38314 bool result;
38315 void *argp1 = 0 ;
38316 int res1 = 0 ;
38317 int val2 ;
38318 int ecode2 = 0 ;
38319 int val3 ;
38320 int ecode3 = 0 ;
38321 int val4 ;
38322 int ecode4 = 0 ;
38323 int val5 ;
38324 int ecode5 = 0 ;
38325 PyObject * obj0 = 0 ;
38326 PyObject * obj1 = 0 ;
38327 PyObject * obj2 = 0 ;
38328 PyObject * obj3 = 0 ;
38329 PyObject * obj4 = 0 ;
38330 char * kwnames[] = {
38331 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
38332 };
38333
38334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) 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_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
38338 }
38339 arg1 = reinterpret_cast< wxWindow * >(argp1);
38340 ecode2 = SWIG_AsVal_int(obj1, &val2);
38341 if (!SWIG_IsOK(ecode2)) {
38342 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
38343 }
38344 arg2 = static_cast< int >(val2);
38345 ecode3 = SWIG_AsVal_int(obj2, &val3);
38346 if (!SWIG_IsOK(ecode3)) {
38347 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
38348 }
38349 arg3 = static_cast< int >(val3);
38350 if (obj3) {
38351 ecode4 = SWIG_AsVal_int(obj3, &val4);
38352 if (!SWIG_IsOK(ecode4)) {
38353 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
38354 }
38355 arg4 = static_cast< int >(val4);
38356 }
38357 if (obj4) {
38358 ecode5 = SWIG_AsVal_int(obj4, &val5);
38359 if (!SWIG_IsOK(ecode5)) {
38360 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
38361 }
38362 arg5 = static_cast< int >(val5);
38363 }
38364 {
38365 PyThreadState* __tstate = wxPyBeginAllowThreads();
38366 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
38367 wxPyEndAllowThreads(__tstate);
38368 if (PyErr_Occurred()) SWIG_fail;
38369 }
38370 {
38371 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38372 }
38373 return resultobj;
38374 fail:
38375 return NULL;
38376 }
38377
38378
38379 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38380 PyObject *resultobj = 0;
38381 wxWindow *arg1 = (wxWindow *) 0 ;
38382 wxPoint *arg2 = 0 ;
38383 bool result;
38384 void *argp1 = 0 ;
38385 int res1 = 0 ;
38386 wxPoint temp2 ;
38387 PyObject * obj0 = 0 ;
38388 PyObject * obj1 = 0 ;
38389 char * kwnames[] = {
38390 (char *) "self",(char *) "pt", NULL
38391 };
38392
38393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
38394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38395 if (!SWIG_IsOK(res1)) {
38396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
38397 }
38398 arg1 = reinterpret_cast< wxWindow * >(argp1);
38399 {
38400 arg2 = &temp2;
38401 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
38402 }
38403 {
38404 PyThreadState* __tstate = wxPyBeginAllowThreads();
38405 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
38406 wxPyEndAllowThreads(__tstate);
38407 if (PyErr_Occurred()) SWIG_fail;
38408 }
38409 {
38410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38411 }
38412 return resultobj;
38413 fail:
38414 return NULL;
38415 }
38416
38417
38418 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38419 PyObject *resultobj = 0;
38420 wxWindow *arg1 = (wxWindow *) 0 ;
38421 wxRect *arg2 = 0 ;
38422 bool result;
38423 void *argp1 = 0 ;
38424 int res1 = 0 ;
38425 wxRect temp2 ;
38426 PyObject * obj0 = 0 ;
38427 PyObject * obj1 = 0 ;
38428 char * kwnames[] = {
38429 (char *) "self",(char *) "rect", NULL
38430 };
38431
38432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
38433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38434 if (!SWIG_IsOK(res1)) {
38435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
38436 }
38437 arg1 = reinterpret_cast< wxWindow * >(argp1);
38438 {
38439 arg2 = &temp2;
38440 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
38441 }
38442 {
38443 PyThreadState* __tstate = wxPyBeginAllowThreads();
38444 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
38445 wxPyEndAllowThreads(__tstate);
38446 if (PyErr_Occurred()) SWIG_fail;
38447 }
38448 {
38449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38450 }
38451 return resultobj;
38452 fail:
38453 return NULL;
38454 }
38455
38456
38457 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38458 PyObject *resultobj = 0;
38459 wxWindow *arg1 = (wxWindow *) 0 ;
38460 SwigValueWrapper<wxVisualAttributes > result;
38461 void *argp1 = 0 ;
38462 int res1 = 0 ;
38463 PyObject *swig_obj[1] ;
38464
38465 if (!args) SWIG_fail;
38466 swig_obj[0] = args;
38467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38468 if (!SWIG_IsOK(res1)) {
38469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
38470 }
38471 arg1 = reinterpret_cast< wxWindow * >(argp1);
38472 {
38473 PyThreadState* __tstate = wxPyBeginAllowThreads();
38474 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
38475 wxPyEndAllowThreads(__tstate);
38476 if (PyErr_Occurred()) SWIG_fail;
38477 }
38478 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
38479 return resultobj;
38480 fail:
38481 return NULL;
38482 }
38483
38484
38485 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38486 PyObject *resultobj = 0;
38487 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
38488 SwigValueWrapper<wxVisualAttributes > result;
38489 int val1 ;
38490 int ecode1 = 0 ;
38491 PyObject * obj0 = 0 ;
38492 char * kwnames[] = {
38493 (char *) "variant", NULL
38494 };
38495
38496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
38497 if (obj0) {
38498 ecode1 = SWIG_AsVal_int(obj0, &val1);
38499 if (!SWIG_IsOK(ecode1)) {
38500 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
38501 }
38502 arg1 = static_cast< wxWindowVariant >(val1);
38503 }
38504 {
38505 if (!wxPyCheckForApp()) SWIG_fail;
38506 PyThreadState* __tstate = wxPyBeginAllowThreads();
38507 result = wxWindow::GetClassDefaultAttributes(arg1);
38508 wxPyEndAllowThreads(__tstate);
38509 if (PyErr_Occurred()) SWIG_fail;
38510 }
38511 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
38512 return resultobj;
38513 fail:
38514 return NULL;
38515 }
38516
38517
38518 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38519 PyObject *resultobj = 0;
38520 wxWindow *arg1 = (wxWindow *) 0 ;
38521 wxColour *arg2 = 0 ;
38522 bool result;
38523 void *argp1 = 0 ;
38524 int res1 = 0 ;
38525 wxColour temp2 ;
38526 PyObject * obj0 = 0 ;
38527 PyObject * obj1 = 0 ;
38528 char * kwnames[] = {
38529 (char *) "self",(char *) "colour", NULL
38530 };
38531
38532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38534 if (!SWIG_IsOK(res1)) {
38535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38536 }
38537 arg1 = reinterpret_cast< wxWindow * >(argp1);
38538 {
38539 arg2 = &temp2;
38540 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38541 }
38542 {
38543 PyThreadState* __tstate = wxPyBeginAllowThreads();
38544 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
38545 wxPyEndAllowThreads(__tstate);
38546 if (PyErr_Occurred()) SWIG_fail;
38547 }
38548 {
38549 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38550 }
38551 return resultobj;
38552 fail:
38553 return NULL;
38554 }
38555
38556
38557 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38558 PyObject *resultobj = 0;
38559 wxWindow *arg1 = (wxWindow *) 0 ;
38560 wxColour *arg2 = 0 ;
38561 void *argp1 = 0 ;
38562 int res1 = 0 ;
38563 wxColour temp2 ;
38564 PyObject * obj0 = 0 ;
38565 PyObject * obj1 = 0 ;
38566 char * kwnames[] = {
38567 (char *) "self",(char *) "colour", NULL
38568 };
38569
38570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38572 if (!SWIG_IsOK(res1)) {
38573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38574 }
38575 arg1 = reinterpret_cast< wxWindow * >(argp1);
38576 {
38577 arg2 = &temp2;
38578 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38579 }
38580 {
38581 PyThreadState* __tstate = wxPyBeginAllowThreads();
38582 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
38583 wxPyEndAllowThreads(__tstate);
38584 if (PyErr_Occurred()) SWIG_fail;
38585 }
38586 resultobj = SWIG_Py_Void();
38587 return resultobj;
38588 fail:
38589 return NULL;
38590 }
38591
38592
38593 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38594 PyObject *resultobj = 0;
38595 wxWindow *arg1 = (wxWindow *) 0 ;
38596 wxColour *arg2 = 0 ;
38597 bool result;
38598 void *argp1 = 0 ;
38599 int res1 = 0 ;
38600 wxColour temp2 ;
38601 PyObject * obj0 = 0 ;
38602 PyObject * obj1 = 0 ;
38603 char * kwnames[] = {
38604 (char *) "self",(char *) "colour", NULL
38605 };
38606
38607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38609 if (!SWIG_IsOK(res1)) {
38610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38611 }
38612 arg1 = reinterpret_cast< wxWindow * >(argp1);
38613 {
38614 arg2 = &temp2;
38615 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38616 }
38617 {
38618 PyThreadState* __tstate = wxPyBeginAllowThreads();
38619 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
38620 wxPyEndAllowThreads(__tstate);
38621 if (PyErr_Occurred()) SWIG_fail;
38622 }
38623 {
38624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38625 }
38626 return resultobj;
38627 fail:
38628 return NULL;
38629 }
38630
38631
38632 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38633 PyObject *resultobj = 0;
38634 wxWindow *arg1 = (wxWindow *) 0 ;
38635 wxColour *arg2 = 0 ;
38636 void *argp1 = 0 ;
38637 int res1 = 0 ;
38638 wxColour temp2 ;
38639 PyObject * obj0 = 0 ;
38640 PyObject * obj1 = 0 ;
38641 char * kwnames[] = {
38642 (char *) "self",(char *) "colour", NULL
38643 };
38644
38645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38647 if (!SWIG_IsOK(res1)) {
38648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38649 }
38650 arg1 = reinterpret_cast< wxWindow * >(argp1);
38651 {
38652 arg2 = &temp2;
38653 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38654 }
38655 {
38656 PyThreadState* __tstate = wxPyBeginAllowThreads();
38657 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
38658 wxPyEndAllowThreads(__tstate);
38659 if (PyErr_Occurred()) SWIG_fail;
38660 }
38661 resultobj = SWIG_Py_Void();
38662 return resultobj;
38663 fail:
38664 return NULL;
38665 }
38666
38667
38668 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38669 PyObject *resultobj = 0;
38670 wxWindow *arg1 = (wxWindow *) 0 ;
38671 wxColour result;
38672 void *argp1 = 0 ;
38673 int res1 = 0 ;
38674 PyObject *swig_obj[1] ;
38675
38676 if (!args) SWIG_fail;
38677 swig_obj[0] = args;
38678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38679 if (!SWIG_IsOK(res1)) {
38680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38681 }
38682 arg1 = reinterpret_cast< wxWindow * >(argp1);
38683 {
38684 PyThreadState* __tstate = wxPyBeginAllowThreads();
38685 result = ((wxWindow const *)arg1)->GetBackgroundColour();
38686 wxPyEndAllowThreads(__tstate);
38687 if (PyErr_Occurred()) SWIG_fail;
38688 }
38689 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
38690 return resultobj;
38691 fail:
38692 return NULL;
38693 }
38694
38695
38696 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38697 PyObject *resultobj = 0;
38698 wxWindow *arg1 = (wxWindow *) 0 ;
38699 wxColour result;
38700 void *argp1 = 0 ;
38701 int res1 = 0 ;
38702 PyObject *swig_obj[1] ;
38703
38704 if (!args) SWIG_fail;
38705 swig_obj[0] = args;
38706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38707 if (!SWIG_IsOK(res1)) {
38708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38709 }
38710 arg1 = reinterpret_cast< wxWindow * >(argp1);
38711 {
38712 PyThreadState* __tstate = wxPyBeginAllowThreads();
38713 result = ((wxWindow const *)arg1)->GetForegroundColour();
38714 wxPyEndAllowThreads(__tstate);
38715 if (PyErr_Occurred()) SWIG_fail;
38716 }
38717 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
38718 return resultobj;
38719 fail:
38720 return NULL;
38721 }
38722
38723
38724 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38725 PyObject *resultobj = 0;
38726 wxWindow *arg1 = (wxWindow *) 0 ;
38727 bool result;
38728 void *argp1 = 0 ;
38729 int res1 = 0 ;
38730 PyObject *swig_obj[1] ;
38731
38732 if (!args) SWIG_fail;
38733 swig_obj[0] = args;
38734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38735 if (!SWIG_IsOK(res1)) {
38736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38737 }
38738 arg1 = reinterpret_cast< wxWindow * >(argp1);
38739 {
38740 PyThreadState* __tstate = wxPyBeginAllowThreads();
38741 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
38742 wxPyEndAllowThreads(__tstate);
38743 if (PyErr_Occurred()) SWIG_fail;
38744 }
38745 {
38746 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38747 }
38748 return resultobj;
38749 fail:
38750 return NULL;
38751 }
38752
38753
38754 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38755 PyObject *resultobj = 0;
38756 wxWindow *arg1 = (wxWindow *) 0 ;
38757 bool result;
38758 void *argp1 = 0 ;
38759 int res1 = 0 ;
38760 PyObject *swig_obj[1] ;
38761
38762 if (!args) SWIG_fail;
38763 swig_obj[0] = args;
38764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38765 if (!SWIG_IsOK(res1)) {
38766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
38767 }
38768 arg1 = reinterpret_cast< wxWindow * >(argp1);
38769 {
38770 PyThreadState* __tstate = wxPyBeginAllowThreads();
38771 result = (bool)((wxWindow const *)arg1)->UseBgCol();
38772 wxPyEndAllowThreads(__tstate);
38773 if (PyErr_Occurred()) SWIG_fail;
38774 }
38775 {
38776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38777 }
38778 return resultobj;
38779 fail:
38780 return NULL;
38781 }
38782
38783
38784 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38785 PyObject *resultobj = 0;
38786 wxWindow *arg1 = (wxWindow *) 0 ;
38787 wxBackgroundStyle arg2 ;
38788 bool result;
38789 void *argp1 = 0 ;
38790 int res1 = 0 ;
38791 int val2 ;
38792 int ecode2 = 0 ;
38793 PyObject * obj0 = 0 ;
38794 PyObject * obj1 = 0 ;
38795 char * kwnames[] = {
38796 (char *) "self",(char *) "style", NULL
38797 };
38798
38799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
38800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38801 if (!SWIG_IsOK(res1)) {
38802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
38803 }
38804 arg1 = reinterpret_cast< wxWindow * >(argp1);
38805 ecode2 = SWIG_AsVal_int(obj1, &val2);
38806 if (!SWIG_IsOK(ecode2)) {
38807 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
38808 }
38809 arg2 = static_cast< wxBackgroundStyle >(val2);
38810 {
38811 PyThreadState* __tstate = wxPyBeginAllowThreads();
38812 result = (bool)(arg1)->SetBackgroundStyle(arg2);
38813 wxPyEndAllowThreads(__tstate);
38814 if (PyErr_Occurred()) SWIG_fail;
38815 }
38816 {
38817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38818 }
38819 return resultobj;
38820 fail:
38821 return NULL;
38822 }
38823
38824
38825 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38826 PyObject *resultobj = 0;
38827 wxWindow *arg1 = (wxWindow *) 0 ;
38828 wxBackgroundStyle result;
38829 void *argp1 = 0 ;
38830 int res1 = 0 ;
38831 PyObject *swig_obj[1] ;
38832
38833 if (!args) SWIG_fail;
38834 swig_obj[0] = args;
38835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38836 if (!SWIG_IsOK(res1)) {
38837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
38838 }
38839 arg1 = reinterpret_cast< wxWindow * >(argp1);
38840 {
38841 PyThreadState* __tstate = wxPyBeginAllowThreads();
38842 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
38843 wxPyEndAllowThreads(__tstate);
38844 if (PyErr_Occurred()) SWIG_fail;
38845 }
38846 resultobj = SWIG_From_int(static_cast< int >(result));
38847 return resultobj;
38848 fail:
38849 return NULL;
38850 }
38851
38852
38853 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38854 PyObject *resultobj = 0;
38855 wxWindow *arg1 = (wxWindow *) 0 ;
38856 bool result;
38857 void *argp1 = 0 ;
38858 int res1 = 0 ;
38859 PyObject *swig_obj[1] ;
38860
38861 if (!args) SWIG_fail;
38862 swig_obj[0] = args;
38863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38864 if (!SWIG_IsOK(res1)) {
38865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
38866 }
38867 arg1 = reinterpret_cast< wxWindow * >(argp1);
38868 {
38869 PyThreadState* __tstate = wxPyBeginAllowThreads();
38870 result = (bool)(arg1)->HasTransparentBackground();
38871 wxPyEndAllowThreads(__tstate);
38872 if (PyErr_Occurred()) SWIG_fail;
38873 }
38874 {
38875 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38876 }
38877 return resultobj;
38878 fail:
38879 return NULL;
38880 }
38881
38882
38883 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38884 PyObject *resultobj = 0;
38885 wxWindow *arg1 = (wxWindow *) 0 ;
38886 wxCursor *arg2 = 0 ;
38887 bool result;
38888 void *argp1 = 0 ;
38889 int res1 = 0 ;
38890 void *argp2 = 0 ;
38891 int res2 = 0 ;
38892 PyObject * obj0 = 0 ;
38893 PyObject * obj1 = 0 ;
38894 char * kwnames[] = {
38895 (char *) "self",(char *) "cursor", NULL
38896 };
38897
38898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
38899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38900 if (!SWIG_IsOK(res1)) {
38901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
38902 }
38903 arg1 = reinterpret_cast< wxWindow * >(argp1);
38904 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
38905 if (!SWIG_IsOK(res2)) {
38906 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
38907 }
38908 if (!argp2) {
38909 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
38910 }
38911 arg2 = reinterpret_cast< wxCursor * >(argp2);
38912 {
38913 PyThreadState* __tstate = wxPyBeginAllowThreads();
38914 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
38915 wxPyEndAllowThreads(__tstate);
38916 if (PyErr_Occurred()) SWIG_fail;
38917 }
38918 {
38919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38920 }
38921 return resultobj;
38922 fail:
38923 return NULL;
38924 }
38925
38926
38927 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38928 PyObject *resultobj = 0;
38929 wxWindow *arg1 = (wxWindow *) 0 ;
38930 wxCursor result;
38931 void *argp1 = 0 ;
38932 int res1 = 0 ;
38933 PyObject *swig_obj[1] ;
38934
38935 if (!args) SWIG_fail;
38936 swig_obj[0] = args;
38937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38938 if (!SWIG_IsOK(res1)) {
38939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
38940 }
38941 arg1 = reinterpret_cast< wxWindow * >(argp1);
38942 {
38943 PyThreadState* __tstate = wxPyBeginAllowThreads();
38944 result = (arg1)->GetCursor();
38945 wxPyEndAllowThreads(__tstate);
38946 if (PyErr_Occurred()) SWIG_fail;
38947 }
38948 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
38949 return resultobj;
38950 fail:
38951 return NULL;
38952 }
38953
38954
38955 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38956 PyObject *resultobj = 0;
38957 wxWindow *arg1 = (wxWindow *) 0 ;
38958 wxFont *arg2 = 0 ;
38959 bool result;
38960 void *argp1 = 0 ;
38961 int res1 = 0 ;
38962 void *argp2 = 0 ;
38963 int res2 = 0 ;
38964 PyObject * obj0 = 0 ;
38965 PyObject * obj1 = 0 ;
38966 char * kwnames[] = {
38967 (char *) "self",(char *) "font", NULL
38968 };
38969
38970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
38971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38972 if (!SWIG_IsOK(res1)) {
38973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38974 }
38975 arg1 = reinterpret_cast< wxWindow * >(argp1);
38976 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
38977 if (!SWIG_IsOK(res2)) {
38978 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38979 }
38980 if (!argp2) {
38981 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38982 }
38983 arg2 = reinterpret_cast< wxFont * >(argp2);
38984 {
38985 PyThreadState* __tstate = wxPyBeginAllowThreads();
38986 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
38987 wxPyEndAllowThreads(__tstate);
38988 if (PyErr_Occurred()) SWIG_fail;
38989 }
38990 {
38991 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38992 }
38993 return resultobj;
38994 fail:
38995 return NULL;
38996 }
38997
38998
38999 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39000 PyObject *resultobj = 0;
39001 wxWindow *arg1 = (wxWindow *) 0 ;
39002 wxFont *arg2 = 0 ;
39003 void *argp1 = 0 ;
39004 int res1 = 0 ;
39005 void *argp2 = 0 ;
39006 int res2 = 0 ;
39007 PyObject * obj0 = 0 ;
39008 PyObject * obj1 = 0 ;
39009 char * kwnames[] = {
39010 (char *) "self",(char *) "font", NULL
39011 };
39012
39013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
39014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39015 if (!SWIG_IsOK(res1)) {
39016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
39017 }
39018 arg1 = reinterpret_cast< wxWindow * >(argp1);
39019 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
39020 if (!SWIG_IsOK(res2)) {
39021 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
39022 }
39023 if (!argp2) {
39024 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
39025 }
39026 arg2 = reinterpret_cast< wxFont * >(argp2);
39027 {
39028 PyThreadState* __tstate = wxPyBeginAllowThreads();
39029 (arg1)->SetOwnFont((wxFont const &)*arg2);
39030 wxPyEndAllowThreads(__tstate);
39031 if (PyErr_Occurred()) SWIG_fail;
39032 }
39033 resultobj = SWIG_Py_Void();
39034 return resultobj;
39035 fail:
39036 return NULL;
39037 }
39038
39039
39040 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39041 PyObject *resultobj = 0;
39042 wxWindow *arg1 = (wxWindow *) 0 ;
39043 wxFont result;
39044 void *argp1 = 0 ;
39045 int res1 = 0 ;
39046 PyObject *swig_obj[1] ;
39047
39048 if (!args) SWIG_fail;
39049 swig_obj[0] = args;
39050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39051 if (!SWIG_IsOK(res1)) {
39052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
39053 }
39054 arg1 = reinterpret_cast< wxWindow * >(argp1);
39055 {
39056 PyThreadState* __tstate = wxPyBeginAllowThreads();
39057 result = (arg1)->GetFont();
39058 wxPyEndAllowThreads(__tstate);
39059 if (PyErr_Occurred()) SWIG_fail;
39060 }
39061 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
39062 return resultobj;
39063 fail:
39064 return NULL;
39065 }
39066
39067
39068 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39069 PyObject *resultobj = 0;
39070 wxWindow *arg1 = (wxWindow *) 0 ;
39071 wxCaret *arg2 = (wxCaret *) 0 ;
39072 void *argp1 = 0 ;
39073 int res1 = 0 ;
39074 int res2 = 0 ;
39075 PyObject * obj0 = 0 ;
39076 PyObject * obj1 = 0 ;
39077 char * kwnames[] = {
39078 (char *) "self",(char *) "caret", NULL
39079 };
39080
39081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
39082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39083 if (!SWIG_IsOK(res1)) {
39084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
39085 }
39086 arg1 = reinterpret_cast< wxWindow * >(argp1);
39087 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
39088 if (!SWIG_IsOK(res2)) {
39089 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
39090 }
39091 {
39092 PyThreadState* __tstate = wxPyBeginAllowThreads();
39093 (arg1)->SetCaret(arg2);
39094 wxPyEndAllowThreads(__tstate);
39095 if (PyErr_Occurred()) SWIG_fail;
39096 }
39097 resultobj = SWIG_Py_Void();
39098 return resultobj;
39099 fail:
39100 return NULL;
39101 }
39102
39103
39104 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39105 PyObject *resultobj = 0;
39106 wxWindow *arg1 = (wxWindow *) 0 ;
39107 wxCaret *result = 0 ;
39108 void *argp1 = 0 ;
39109 int res1 = 0 ;
39110 PyObject *swig_obj[1] ;
39111
39112 if (!args) SWIG_fail;
39113 swig_obj[0] = args;
39114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39115 if (!SWIG_IsOK(res1)) {
39116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
39117 }
39118 arg1 = reinterpret_cast< wxWindow * >(argp1);
39119 {
39120 PyThreadState* __tstate = wxPyBeginAllowThreads();
39121 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
39122 wxPyEndAllowThreads(__tstate);
39123 if (PyErr_Occurred()) SWIG_fail;
39124 }
39125 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
39126 return resultobj;
39127 fail:
39128 return NULL;
39129 }
39130
39131
39132 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39133 PyObject *resultobj = 0;
39134 wxWindow *arg1 = (wxWindow *) 0 ;
39135 int result;
39136 void *argp1 = 0 ;
39137 int res1 = 0 ;
39138 PyObject *swig_obj[1] ;
39139
39140 if (!args) SWIG_fail;
39141 swig_obj[0] = args;
39142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39143 if (!SWIG_IsOK(res1)) {
39144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
39145 }
39146 arg1 = reinterpret_cast< wxWindow * >(argp1);
39147 {
39148 PyThreadState* __tstate = wxPyBeginAllowThreads();
39149 result = (int)((wxWindow const *)arg1)->GetCharHeight();
39150 wxPyEndAllowThreads(__tstate);
39151 if (PyErr_Occurred()) SWIG_fail;
39152 }
39153 resultobj = SWIG_From_int(static_cast< int >(result));
39154 return resultobj;
39155 fail:
39156 return NULL;
39157 }
39158
39159
39160 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39161 PyObject *resultobj = 0;
39162 wxWindow *arg1 = (wxWindow *) 0 ;
39163 int result;
39164 void *argp1 = 0 ;
39165 int res1 = 0 ;
39166 PyObject *swig_obj[1] ;
39167
39168 if (!args) SWIG_fail;
39169 swig_obj[0] = args;
39170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39171 if (!SWIG_IsOK(res1)) {
39172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
39173 }
39174 arg1 = reinterpret_cast< wxWindow * >(argp1);
39175 {
39176 PyThreadState* __tstate = wxPyBeginAllowThreads();
39177 result = (int)((wxWindow const *)arg1)->GetCharWidth();
39178 wxPyEndAllowThreads(__tstate);
39179 if (PyErr_Occurred()) SWIG_fail;
39180 }
39181 resultobj = SWIG_From_int(static_cast< int >(result));
39182 return resultobj;
39183 fail:
39184 return NULL;
39185 }
39186
39187
39188 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39189 PyObject *resultobj = 0;
39190 wxWindow *arg1 = (wxWindow *) 0 ;
39191 wxString *arg2 = 0 ;
39192 int *arg3 = (int *) 0 ;
39193 int *arg4 = (int *) 0 ;
39194 void *argp1 = 0 ;
39195 int res1 = 0 ;
39196 bool temp2 = false ;
39197 int temp3 ;
39198 int res3 = SWIG_TMPOBJ ;
39199 int temp4 ;
39200 int res4 = SWIG_TMPOBJ ;
39201 PyObject * obj0 = 0 ;
39202 PyObject * obj1 = 0 ;
39203 char * kwnames[] = {
39204 (char *) "self",(char *) "string", NULL
39205 };
39206
39207 arg3 = &temp3;
39208 arg4 = &temp4;
39209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
39210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39211 if (!SWIG_IsOK(res1)) {
39212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
39213 }
39214 arg1 = reinterpret_cast< wxWindow * >(argp1);
39215 {
39216 arg2 = wxString_in_helper(obj1);
39217 if (arg2 == NULL) SWIG_fail;
39218 temp2 = true;
39219 }
39220 {
39221 PyThreadState* __tstate = wxPyBeginAllowThreads();
39222 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
39223 wxPyEndAllowThreads(__tstate);
39224 if (PyErr_Occurred()) SWIG_fail;
39225 }
39226 resultobj = SWIG_Py_Void();
39227 if (SWIG_IsTmpObj(res3)) {
39228 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39229 } else {
39230 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39231 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39232 }
39233 if (SWIG_IsTmpObj(res4)) {
39234 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
39235 } else {
39236 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39237 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
39238 }
39239 {
39240 if (temp2)
39241 delete arg2;
39242 }
39243 return resultobj;
39244 fail:
39245 {
39246 if (temp2)
39247 delete arg2;
39248 }
39249 return NULL;
39250 }
39251
39252
39253 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39254 PyObject *resultobj = 0;
39255 wxWindow *arg1 = (wxWindow *) 0 ;
39256 wxString *arg2 = 0 ;
39257 int *arg3 = (int *) 0 ;
39258 int *arg4 = (int *) 0 ;
39259 int *arg5 = (int *) 0 ;
39260 int *arg6 = (int *) 0 ;
39261 wxFont *arg7 = (wxFont *) NULL ;
39262 void *argp1 = 0 ;
39263 int res1 = 0 ;
39264 bool temp2 = false ;
39265 int temp3 ;
39266 int res3 = SWIG_TMPOBJ ;
39267 int temp4 ;
39268 int res4 = SWIG_TMPOBJ ;
39269 int temp5 ;
39270 int res5 = SWIG_TMPOBJ ;
39271 int temp6 ;
39272 int res6 = SWIG_TMPOBJ ;
39273 void *argp7 = 0 ;
39274 int res7 = 0 ;
39275 PyObject * obj0 = 0 ;
39276 PyObject * obj1 = 0 ;
39277 PyObject * obj2 = 0 ;
39278 char * kwnames[] = {
39279 (char *) "self",(char *) "string",(char *) "font", NULL
39280 };
39281
39282 arg3 = &temp3;
39283 arg4 = &temp4;
39284 arg5 = &temp5;
39285 arg6 = &temp6;
39286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39288 if (!SWIG_IsOK(res1)) {
39289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
39290 }
39291 arg1 = reinterpret_cast< wxWindow * >(argp1);
39292 {
39293 arg2 = wxString_in_helper(obj1);
39294 if (arg2 == NULL) SWIG_fail;
39295 temp2 = true;
39296 }
39297 if (obj2) {
39298 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
39299 if (!SWIG_IsOK(res7)) {
39300 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
39301 }
39302 arg7 = reinterpret_cast< wxFont * >(argp7);
39303 }
39304 {
39305 PyThreadState* __tstate = wxPyBeginAllowThreads();
39306 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
39307 wxPyEndAllowThreads(__tstate);
39308 if (PyErr_Occurred()) SWIG_fail;
39309 }
39310 resultobj = SWIG_Py_Void();
39311 if (SWIG_IsTmpObj(res3)) {
39312 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39313 } else {
39314 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39315 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39316 }
39317 if (SWIG_IsTmpObj(res4)) {
39318 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
39319 } else {
39320 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39321 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
39322 }
39323 if (SWIG_IsTmpObj(res5)) {
39324 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
39325 } else {
39326 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39327 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
39328 }
39329 if (SWIG_IsTmpObj(res6)) {
39330 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
39331 } else {
39332 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39333 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
39334 }
39335 {
39336 if (temp2)
39337 delete arg2;
39338 }
39339 return resultobj;
39340 fail:
39341 {
39342 if (temp2)
39343 delete arg2;
39344 }
39345 return NULL;
39346 }
39347
39348
39349 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39350 PyObject *resultobj = 0;
39351 wxWindow *arg1 = (wxWindow *) 0 ;
39352 int *arg2 = (int *) 0 ;
39353 int *arg3 = (int *) 0 ;
39354 void *argp1 = 0 ;
39355 int res1 = 0 ;
39356 int temp2 ;
39357 int res2 = 0 ;
39358 int temp3 ;
39359 int res3 = 0 ;
39360 PyObject * obj0 = 0 ;
39361 PyObject * obj1 = 0 ;
39362 PyObject * obj2 = 0 ;
39363 char * kwnames[] = {
39364 (char *) "self",(char *) "x",(char *) "y", NULL
39365 };
39366
39367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39369 if (!SWIG_IsOK(res1)) {
39370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39371 }
39372 arg1 = reinterpret_cast< wxWindow * >(argp1);
39373 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
39374 int val;
39375 int ecode = SWIG_AsVal_int(obj1, &val);
39376 if (!SWIG_IsOK(ecode)) {
39377 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
39378 }
39379 temp2 = static_cast< int >(val);
39380 arg2 = &temp2;
39381 res2 = SWIG_AddTmpMask(ecode);
39382 }
39383 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
39384 int val;
39385 int ecode = SWIG_AsVal_int(obj2, &val);
39386 if (!SWIG_IsOK(ecode)) {
39387 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
39388 }
39389 temp3 = static_cast< int >(val);
39390 arg3 = &temp3;
39391 res3 = SWIG_AddTmpMask(ecode);
39392 }
39393 {
39394 PyThreadState* __tstate = wxPyBeginAllowThreads();
39395 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
39396 wxPyEndAllowThreads(__tstate);
39397 if (PyErr_Occurred()) SWIG_fail;
39398 }
39399 resultobj = SWIG_Py_Void();
39400 if (SWIG_IsTmpObj(res2)) {
39401 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
39402 } else {
39403 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39404 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
39405 }
39406 if (SWIG_IsTmpObj(res3)) {
39407 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39408 } else {
39409 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39410 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39411 }
39412 return resultobj;
39413 fail:
39414 return NULL;
39415 }
39416
39417
39418 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39419 PyObject *resultobj = 0;
39420 wxWindow *arg1 = (wxWindow *) 0 ;
39421 int *arg2 = (int *) 0 ;
39422 int *arg3 = (int *) 0 ;
39423 void *argp1 = 0 ;
39424 int res1 = 0 ;
39425 int temp2 ;
39426 int res2 = 0 ;
39427 int temp3 ;
39428 int res3 = 0 ;
39429 PyObject * obj0 = 0 ;
39430 PyObject * obj1 = 0 ;
39431 PyObject * obj2 = 0 ;
39432 char * kwnames[] = {
39433 (char *) "self",(char *) "x",(char *) "y", NULL
39434 };
39435
39436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39438 if (!SWIG_IsOK(res1)) {
39439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39440 }
39441 arg1 = reinterpret_cast< wxWindow * >(argp1);
39442 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
39443 int val;
39444 int ecode = SWIG_AsVal_int(obj1, &val);
39445 if (!SWIG_IsOK(ecode)) {
39446 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
39447 }
39448 temp2 = static_cast< int >(val);
39449 arg2 = &temp2;
39450 res2 = SWIG_AddTmpMask(ecode);
39451 }
39452 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
39453 int val;
39454 int ecode = SWIG_AsVal_int(obj2, &val);
39455 if (!SWIG_IsOK(ecode)) {
39456 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
39457 }
39458 temp3 = static_cast< int >(val);
39459 arg3 = &temp3;
39460 res3 = SWIG_AddTmpMask(ecode);
39461 }
39462 {
39463 PyThreadState* __tstate = wxPyBeginAllowThreads();
39464 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
39465 wxPyEndAllowThreads(__tstate);
39466 if (PyErr_Occurred()) SWIG_fail;
39467 }
39468 resultobj = SWIG_Py_Void();
39469 if (SWIG_IsTmpObj(res2)) {
39470 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
39471 } else {
39472 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39473 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
39474 }
39475 if (SWIG_IsTmpObj(res3)) {
39476 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39477 } else {
39478 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39479 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39480 }
39481 return resultobj;
39482 fail:
39483 return NULL;
39484 }
39485
39486
39487 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39488 PyObject *resultobj = 0;
39489 wxWindow *arg1 = (wxWindow *) 0 ;
39490 wxPoint *arg2 = 0 ;
39491 wxPoint result;
39492 void *argp1 = 0 ;
39493 int res1 = 0 ;
39494 wxPoint temp2 ;
39495 PyObject * obj0 = 0 ;
39496 PyObject * obj1 = 0 ;
39497 char * kwnames[] = {
39498 (char *) "self",(char *) "pt", NULL
39499 };
39500
39501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
39502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39503 if (!SWIG_IsOK(res1)) {
39504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
39505 }
39506 arg1 = reinterpret_cast< wxWindow * >(argp1);
39507 {
39508 arg2 = &temp2;
39509 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39510 }
39511 {
39512 PyThreadState* __tstate = wxPyBeginAllowThreads();
39513 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
39514 wxPyEndAllowThreads(__tstate);
39515 if (PyErr_Occurred()) SWIG_fail;
39516 }
39517 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
39518 return resultobj;
39519 fail:
39520 return NULL;
39521 }
39522
39523
39524 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39525 PyObject *resultobj = 0;
39526 wxWindow *arg1 = (wxWindow *) 0 ;
39527 wxPoint *arg2 = 0 ;
39528 wxPoint result;
39529 void *argp1 = 0 ;
39530 int res1 = 0 ;
39531 wxPoint temp2 ;
39532 PyObject * obj0 = 0 ;
39533 PyObject * obj1 = 0 ;
39534 char * kwnames[] = {
39535 (char *) "self",(char *) "pt", NULL
39536 };
39537
39538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
39539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39540 if (!SWIG_IsOK(res1)) {
39541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
39542 }
39543 arg1 = reinterpret_cast< wxWindow * >(argp1);
39544 {
39545 arg2 = &temp2;
39546 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39547 }
39548 {
39549 PyThreadState* __tstate = wxPyBeginAllowThreads();
39550 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
39551 wxPyEndAllowThreads(__tstate);
39552 if (PyErr_Occurred()) SWIG_fail;
39553 }
39554 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
39555 return resultobj;
39556 fail:
39557 return NULL;
39558 }
39559
39560
39561 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39562 PyObject *resultobj = 0;
39563 wxWindow *arg1 = (wxWindow *) 0 ;
39564 int arg2 ;
39565 int arg3 ;
39566 wxHitTest result;
39567 void *argp1 = 0 ;
39568 int res1 = 0 ;
39569 int val2 ;
39570 int ecode2 = 0 ;
39571 int val3 ;
39572 int ecode3 = 0 ;
39573 PyObject * obj0 = 0 ;
39574 PyObject * obj1 = 0 ;
39575 PyObject * obj2 = 0 ;
39576 char * kwnames[] = {
39577 (char *) "self",(char *) "x",(char *) "y", NULL
39578 };
39579
39580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39582 if (!SWIG_IsOK(res1)) {
39583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39584 }
39585 arg1 = reinterpret_cast< wxWindow * >(argp1);
39586 ecode2 = SWIG_AsVal_int(obj1, &val2);
39587 if (!SWIG_IsOK(ecode2)) {
39588 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
39589 }
39590 arg2 = static_cast< int >(val2);
39591 ecode3 = SWIG_AsVal_int(obj2, &val3);
39592 if (!SWIG_IsOK(ecode3)) {
39593 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
39594 }
39595 arg3 = static_cast< int >(val3);
39596 {
39597 PyThreadState* __tstate = wxPyBeginAllowThreads();
39598 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
39599 wxPyEndAllowThreads(__tstate);
39600 if (PyErr_Occurred()) SWIG_fail;
39601 }
39602 resultobj = SWIG_From_int(static_cast< int >(result));
39603 return resultobj;
39604 fail:
39605 return NULL;
39606 }
39607
39608
39609 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39610 PyObject *resultobj = 0;
39611 wxWindow *arg1 = (wxWindow *) 0 ;
39612 wxPoint *arg2 = 0 ;
39613 wxHitTest result;
39614 void *argp1 = 0 ;
39615 int res1 = 0 ;
39616 wxPoint temp2 ;
39617 PyObject * obj0 = 0 ;
39618 PyObject * obj1 = 0 ;
39619 char * kwnames[] = {
39620 (char *) "self",(char *) "pt", NULL
39621 };
39622
39623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
39624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39625 if (!SWIG_IsOK(res1)) {
39626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
39627 }
39628 arg1 = reinterpret_cast< wxWindow * >(argp1);
39629 {
39630 arg2 = &temp2;
39631 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39632 }
39633 {
39634 PyThreadState* __tstate = wxPyBeginAllowThreads();
39635 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
39636 wxPyEndAllowThreads(__tstate);
39637 if (PyErr_Occurred()) SWIG_fail;
39638 }
39639 resultobj = SWIG_From_int(static_cast< int >(result));
39640 return resultobj;
39641 fail:
39642 return NULL;
39643 }
39644
39645
39646 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
39647 PyObject *resultobj = 0;
39648 wxWindow *arg1 = (wxWindow *) 0 ;
39649 long arg2 ;
39650 wxBorder result;
39651 void *argp1 = 0 ;
39652 int res1 = 0 ;
39653 long val2 ;
39654 int ecode2 = 0 ;
39655
39656 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
39657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39658 if (!SWIG_IsOK(res1)) {
39659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
39660 }
39661 arg1 = reinterpret_cast< wxWindow * >(argp1);
39662 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
39663 if (!SWIG_IsOK(ecode2)) {
39664 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
39665 }
39666 arg2 = static_cast< long >(val2);
39667 {
39668 PyThreadState* __tstate = wxPyBeginAllowThreads();
39669 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
39670 wxPyEndAllowThreads(__tstate);
39671 if (PyErr_Occurred()) SWIG_fail;
39672 }
39673 resultobj = SWIG_From_int(static_cast< int >(result));
39674 return resultobj;
39675 fail:
39676 return NULL;
39677 }
39678
39679
39680 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
39681 PyObject *resultobj = 0;
39682 wxWindow *arg1 = (wxWindow *) 0 ;
39683 wxBorder result;
39684 void *argp1 = 0 ;
39685 int res1 = 0 ;
39686
39687 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
39688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39689 if (!SWIG_IsOK(res1)) {
39690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
39691 }
39692 arg1 = reinterpret_cast< wxWindow * >(argp1);
39693 {
39694 PyThreadState* __tstate = wxPyBeginAllowThreads();
39695 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
39696 wxPyEndAllowThreads(__tstate);
39697 if (PyErr_Occurred()) SWIG_fail;
39698 }
39699 resultobj = SWIG_From_int(static_cast< int >(result));
39700 return resultobj;
39701 fail:
39702 return NULL;
39703 }
39704
39705
39706 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
39707 int argc;
39708 PyObject *argv[3];
39709
39710 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
39711 --argc;
39712 if (argc == 1) {
39713 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
39714 }
39715 if (argc == 2) {
39716 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
39717 }
39718
39719 fail:
39720 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
39721 return NULL;
39722 }
39723
39724
39725 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39726 PyObject *resultobj = 0;
39727 wxWindow *arg1 = (wxWindow *) 0 ;
39728 long arg2 = (long) wxUPDATE_UI_NONE ;
39729 void *argp1 = 0 ;
39730 int res1 = 0 ;
39731 long val2 ;
39732 int ecode2 = 0 ;
39733 PyObject * obj0 = 0 ;
39734 PyObject * obj1 = 0 ;
39735 char * kwnames[] = {
39736 (char *) "self",(char *) "flags", NULL
39737 };
39738
39739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
39740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39741 if (!SWIG_IsOK(res1)) {
39742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
39743 }
39744 arg1 = reinterpret_cast< wxWindow * >(argp1);
39745 if (obj1) {
39746 ecode2 = SWIG_AsVal_long(obj1, &val2);
39747 if (!SWIG_IsOK(ecode2)) {
39748 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
39749 }
39750 arg2 = static_cast< long >(val2);
39751 }
39752 {
39753 PyThreadState* __tstate = wxPyBeginAllowThreads();
39754 (arg1)->UpdateWindowUI(arg2);
39755 wxPyEndAllowThreads(__tstate);
39756 if (PyErr_Occurred()) SWIG_fail;
39757 }
39758 resultobj = SWIG_Py_Void();
39759 return resultobj;
39760 fail:
39761 return NULL;
39762 }
39763
39764
39765 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39766 PyObject *resultobj = 0;
39767 wxWindow *arg1 = (wxWindow *) 0 ;
39768 wxMenu *arg2 = (wxMenu *) 0 ;
39769 int arg3 = (int) -1 ;
39770 int arg4 = (int) -1 ;
39771 bool result;
39772 void *argp1 = 0 ;
39773 int res1 = 0 ;
39774 void *argp2 = 0 ;
39775 int res2 = 0 ;
39776 int val3 ;
39777 int ecode3 = 0 ;
39778 int val4 ;
39779 int ecode4 = 0 ;
39780 PyObject * obj0 = 0 ;
39781 PyObject * obj1 = 0 ;
39782 PyObject * obj2 = 0 ;
39783 PyObject * obj3 = 0 ;
39784 char * kwnames[] = {
39785 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
39786 };
39787
39788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39790 if (!SWIG_IsOK(res1)) {
39791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
39792 }
39793 arg1 = reinterpret_cast< wxWindow * >(argp1);
39794 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39795 if (!SWIG_IsOK(res2)) {
39796 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
39797 }
39798 arg2 = reinterpret_cast< wxMenu * >(argp2);
39799 if (obj2) {
39800 ecode3 = SWIG_AsVal_int(obj2, &val3);
39801 if (!SWIG_IsOK(ecode3)) {
39802 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
39803 }
39804 arg3 = static_cast< int >(val3);
39805 }
39806 if (obj3) {
39807 ecode4 = SWIG_AsVal_int(obj3, &val4);
39808 if (!SWIG_IsOK(ecode4)) {
39809 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
39810 }
39811 arg4 = static_cast< int >(val4);
39812 }
39813 {
39814 PyThreadState* __tstate = wxPyBeginAllowThreads();
39815 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
39816 wxPyEndAllowThreads(__tstate);
39817 if (PyErr_Occurred()) SWIG_fail;
39818 }
39819 {
39820 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39821 }
39822 return resultobj;
39823 fail:
39824 return NULL;
39825 }
39826
39827
39828 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39829 PyObject *resultobj = 0;
39830 wxWindow *arg1 = (wxWindow *) 0 ;
39831 wxMenu *arg2 = (wxMenu *) 0 ;
39832 wxPoint const &arg3_defvalue = wxDefaultPosition ;
39833 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
39834 bool result;
39835 void *argp1 = 0 ;
39836 int res1 = 0 ;
39837 void *argp2 = 0 ;
39838 int res2 = 0 ;
39839 wxPoint temp3 ;
39840 PyObject * obj0 = 0 ;
39841 PyObject * obj1 = 0 ;
39842 PyObject * obj2 = 0 ;
39843 char * kwnames[] = {
39844 (char *) "self",(char *) "menu",(char *) "pos", NULL
39845 };
39846
39847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39849 if (!SWIG_IsOK(res1)) {
39850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
39851 }
39852 arg1 = reinterpret_cast< wxWindow * >(argp1);
39853 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39854 if (!SWIG_IsOK(res2)) {
39855 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
39856 }
39857 arg2 = reinterpret_cast< wxMenu * >(argp2);
39858 if (obj2) {
39859 {
39860 arg3 = &temp3;
39861 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
39862 }
39863 }
39864 {
39865 PyThreadState* __tstate = wxPyBeginAllowThreads();
39866 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
39867 wxPyEndAllowThreads(__tstate);
39868 if (PyErr_Occurred()) SWIG_fail;
39869 }
39870 {
39871 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39872 }
39873 return resultobj;
39874 fail:
39875 return NULL;
39876 }
39877
39878
39879 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39880 PyObject *resultobj = 0;
39881 wxWindow *arg1 = (wxWindow *) 0 ;
39882 bool result;
39883 void *argp1 = 0 ;
39884 int res1 = 0 ;
39885 PyObject *swig_obj[1] ;
39886
39887 if (!args) SWIG_fail;
39888 swig_obj[0] = args;
39889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39890 if (!SWIG_IsOK(res1)) {
39891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
39892 }
39893 arg1 = reinterpret_cast< wxWindow * >(argp1);
39894 {
39895 PyThreadState* __tstate = wxPyBeginAllowThreads();
39896 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
39897 wxPyEndAllowThreads(__tstate);
39898 if (PyErr_Occurred()) SWIG_fail;
39899 }
39900 {
39901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39902 }
39903 return resultobj;
39904 fail:
39905 return NULL;
39906 }
39907
39908
39909 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39910 PyObject *resultobj = 0;
39911 wxWindow *arg1 = (wxWindow *) 0 ;
39912 long result;
39913 void *argp1 = 0 ;
39914 int res1 = 0 ;
39915 PyObject *swig_obj[1] ;
39916
39917 if (!args) SWIG_fail;
39918 swig_obj[0] = args;
39919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39920 if (!SWIG_IsOK(res1)) {
39921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39922 }
39923 arg1 = reinterpret_cast< wxWindow * >(argp1);
39924 {
39925 PyThreadState* __tstate = wxPyBeginAllowThreads();
39926 result = (long)wxWindow_GetHandle(arg1);
39927 wxPyEndAllowThreads(__tstate);
39928 if (PyErr_Occurred()) SWIG_fail;
39929 }
39930 resultobj = SWIG_From_long(static_cast< long >(result));
39931 return resultobj;
39932 fail:
39933 return NULL;
39934 }
39935
39936
39937 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39938 PyObject *resultobj = 0;
39939 wxWindow *arg1 = (wxWindow *) 0 ;
39940 long arg2 ;
39941 void *argp1 = 0 ;
39942 int res1 = 0 ;
39943 long val2 ;
39944 int ecode2 = 0 ;
39945 PyObject * obj0 = 0 ;
39946 PyObject * obj1 = 0 ;
39947 char * kwnames[] = {
39948 (char *) "self",(char *) "handle", NULL
39949 };
39950
39951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
39952 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39953 if (!SWIG_IsOK(res1)) {
39954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39955 }
39956 arg1 = reinterpret_cast< wxWindow * >(argp1);
39957 ecode2 = SWIG_AsVal_long(obj1, &val2);
39958 if (!SWIG_IsOK(ecode2)) {
39959 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
39960 }
39961 arg2 = static_cast< long >(val2);
39962 {
39963 PyThreadState* __tstate = wxPyBeginAllowThreads();
39964 wxWindow_AssociateHandle(arg1,arg2);
39965 wxPyEndAllowThreads(__tstate);
39966 if (PyErr_Occurred()) SWIG_fail;
39967 }
39968 resultobj = SWIG_Py_Void();
39969 return resultobj;
39970 fail:
39971 return NULL;
39972 }
39973
39974
39975 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39976 PyObject *resultobj = 0;
39977 wxWindow *arg1 = (wxWindow *) 0 ;
39978 void *argp1 = 0 ;
39979 int res1 = 0 ;
39980 PyObject *swig_obj[1] ;
39981
39982 if (!args) SWIG_fail;
39983 swig_obj[0] = args;
39984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39985 if (!SWIG_IsOK(res1)) {
39986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39987 }
39988 arg1 = reinterpret_cast< wxWindow * >(argp1);
39989 {
39990 PyThreadState* __tstate = wxPyBeginAllowThreads();
39991 (arg1)->DissociateHandle();
39992 wxPyEndAllowThreads(__tstate);
39993 if (PyErr_Occurred()) SWIG_fail;
39994 }
39995 resultobj = SWIG_Py_Void();
39996 return resultobj;
39997 fail:
39998 return NULL;
39999 }
40000
40001
40002 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40003 PyObject *resultobj = 0;
40004 wxWindow *arg1 = (wxWindow *) 0 ;
40005 int arg2 ;
40006 bool result;
40007 void *argp1 = 0 ;
40008 int res1 = 0 ;
40009 int val2 ;
40010 int ecode2 = 0 ;
40011 PyObject * obj0 = 0 ;
40012 PyObject * obj1 = 0 ;
40013 char * kwnames[] = {
40014 (char *) "self",(char *) "orient", NULL
40015 };
40016
40017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
40018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40019 if (!SWIG_IsOK(res1)) {
40020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
40021 }
40022 arg1 = reinterpret_cast< wxWindow * >(argp1);
40023 ecode2 = SWIG_AsVal_int(obj1, &val2);
40024 if (!SWIG_IsOK(ecode2)) {
40025 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
40026 }
40027 arg2 = static_cast< int >(val2);
40028 {
40029 PyThreadState* __tstate = wxPyBeginAllowThreads();
40030 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
40031 wxPyEndAllowThreads(__tstate);
40032 if (PyErr_Occurred()) SWIG_fail;
40033 }
40034 {
40035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40036 }
40037 return resultobj;
40038 fail:
40039 return NULL;
40040 }
40041
40042
40043 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40044 PyObject *resultobj = 0;
40045 wxWindow *arg1 = (wxWindow *) 0 ;
40046 int arg2 ;
40047 int arg3 ;
40048 int arg4 ;
40049 int arg5 ;
40050 bool arg6 = (bool) true ;
40051 void *argp1 = 0 ;
40052 int res1 = 0 ;
40053 int val2 ;
40054 int ecode2 = 0 ;
40055 int val3 ;
40056 int ecode3 = 0 ;
40057 int val4 ;
40058 int ecode4 = 0 ;
40059 int val5 ;
40060 int ecode5 = 0 ;
40061 bool val6 ;
40062 int ecode6 = 0 ;
40063 PyObject * obj0 = 0 ;
40064 PyObject * obj1 = 0 ;
40065 PyObject * obj2 = 0 ;
40066 PyObject * obj3 = 0 ;
40067 PyObject * obj4 = 0 ;
40068 PyObject * obj5 = 0 ;
40069 char * kwnames[] = {
40070 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
40071 };
40072
40073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
40074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40075 if (!SWIG_IsOK(res1)) {
40076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
40077 }
40078 arg1 = reinterpret_cast< wxWindow * >(argp1);
40079 ecode2 = SWIG_AsVal_int(obj1, &val2);
40080 if (!SWIG_IsOK(ecode2)) {
40081 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
40082 }
40083 arg2 = static_cast< int >(val2);
40084 ecode3 = SWIG_AsVal_int(obj2, &val3);
40085 if (!SWIG_IsOK(ecode3)) {
40086 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
40087 }
40088 arg3 = static_cast< int >(val3);
40089 ecode4 = SWIG_AsVal_int(obj3, &val4);
40090 if (!SWIG_IsOK(ecode4)) {
40091 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
40092 }
40093 arg4 = static_cast< int >(val4);
40094 ecode5 = SWIG_AsVal_int(obj4, &val5);
40095 if (!SWIG_IsOK(ecode5)) {
40096 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
40097 }
40098 arg5 = static_cast< int >(val5);
40099 if (obj5) {
40100 ecode6 = SWIG_AsVal_bool(obj5, &val6);
40101 if (!SWIG_IsOK(ecode6)) {
40102 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
40103 }
40104 arg6 = static_cast< bool >(val6);
40105 }
40106 {
40107 PyThreadState* __tstate = wxPyBeginAllowThreads();
40108 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
40109 wxPyEndAllowThreads(__tstate);
40110 if (PyErr_Occurred()) SWIG_fail;
40111 }
40112 resultobj = SWIG_Py_Void();
40113 return resultobj;
40114 fail:
40115 return NULL;
40116 }
40117
40118
40119 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40120 PyObject *resultobj = 0;
40121 wxWindow *arg1 = (wxWindow *) 0 ;
40122 int arg2 ;
40123 int arg3 ;
40124 bool arg4 = (bool) true ;
40125 void *argp1 = 0 ;
40126 int res1 = 0 ;
40127 int val2 ;
40128 int ecode2 = 0 ;
40129 int val3 ;
40130 int ecode3 = 0 ;
40131 bool val4 ;
40132 int ecode4 = 0 ;
40133 PyObject * obj0 = 0 ;
40134 PyObject * obj1 = 0 ;
40135 PyObject * obj2 = 0 ;
40136 PyObject * obj3 = 0 ;
40137 char * kwnames[] = {
40138 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
40139 };
40140
40141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40143 if (!SWIG_IsOK(res1)) {
40144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
40145 }
40146 arg1 = reinterpret_cast< wxWindow * >(argp1);
40147 ecode2 = SWIG_AsVal_int(obj1, &val2);
40148 if (!SWIG_IsOK(ecode2)) {
40149 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
40150 }
40151 arg2 = static_cast< int >(val2);
40152 ecode3 = SWIG_AsVal_int(obj2, &val3);
40153 if (!SWIG_IsOK(ecode3)) {
40154 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
40155 }
40156 arg3 = static_cast< int >(val3);
40157 if (obj3) {
40158 ecode4 = SWIG_AsVal_bool(obj3, &val4);
40159 if (!SWIG_IsOK(ecode4)) {
40160 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
40161 }
40162 arg4 = static_cast< bool >(val4);
40163 }
40164 {
40165 PyThreadState* __tstate = wxPyBeginAllowThreads();
40166 (arg1)->SetScrollPos(arg2,arg3,arg4);
40167 wxPyEndAllowThreads(__tstate);
40168 if (PyErr_Occurred()) SWIG_fail;
40169 }
40170 resultobj = SWIG_Py_Void();
40171 return resultobj;
40172 fail:
40173 return NULL;
40174 }
40175
40176
40177 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40178 PyObject *resultobj = 0;
40179 wxWindow *arg1 = (wxWindow *) 0 ;
40180 int arg2 ;
40181 int result;
40182 void *argp1 = 0 ;
40183 int res1 = 0 ;
40184 int val2 ;
40185 int ecode2 = 0 ;
40186 PyObject * obj0 = 0 ;
40187 PyObject * obj1 = 0 ;
40188 char * kwnames[] = {
40189 (char *) "self",(char *) "orientation", NULL
40190 };
40191
40192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
40193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40194 if (!SWIG_IsOK(res1)) {
40195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
40196 }
40197 arg1 = reinterpret_cast< wxWindow * >(argp1);
40198 ecode2 = SWIG_AsVal_int(obj1, &val2);
40199 if (!SWIG_IsOK(ecode2)) {
40200 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
40201 }
40202 arg2 = static_cast< int >(val2);
40203 {
40204 PyThreadState* __tstate = wxPyBeginAllowThreads();
40205 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
40206 wxPyEndAllowThreads(__tstate);
40207 if (PyErr_Occurred()) SWIG_fail;
40208 }
40209 resultobj = SWIG_From_int(static_cast< int >(result));
40210 return resultobj;
40211 fail:
40212 return NULL;
40213 }
40214
40215
40216 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40217 PyObject *resultobj = 0;
40218 wxWindow *arg1 = (wxWindow *) 0 ;
40219 int arg2 ;
40220 int result;
40221 void *argp1 = 0 ;
40222 int res1 = 0 ;
40223 int val2 ;
40224 int ecode2 = 0 ;
40225 PyObject * obj0 = 0 ;
40226 PyObject * obj1 = 0 ;
40227 char * kwnames[] = {
40228 (char *) "self",(char *) "orientation", NULL
40229 };
40230
40231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
40232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40233 if (!SWIG_IsOK(res1)) {
40234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
40235 }
40236 arg1 = reinterpret_cast< wxWindow * >(argp1);
40237 ecode2 = SWIG_AsVal_int(obj1, &val2);
40238 if (!SWIG_IsOK(ecode2)) {
40239 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
40240 }
40241 arg2 = static_cast< int >(val2);
40242 {
40243 PyThreadState* __tstate = wxPyBeginAllowThreads();
40244 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
40245 wxPyEndAllowThreads(__tstate);
40246 if (PyErr_Occurred()) SWIG_fail;
40247 }
40248 resultobj = SWIG_From_int(static_cast< int >(result));
40249 return resultobj;
40250 fail:
40251 return NULL;
40252 }
40253
40254
40255 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40256 PyObject *resultobj = 0;
40257 wxWindow *arg1 = (wxWindow *) 0 ;
40258 int arg2 ;
40259 int result;
40260 void *argp1 = 0 ;
40261 int res1 = 0 ;
40262 int val2 ;
40263 int ecode2 = 0 ;
40264 PyObject * obj0 = 0 ;
40265 PyObject * obj1 = 0 ;
40266 char * kwnames[] = {
40267 (char *) "self",(char *) "orientation", NULL
40268 };
40269
40270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
40271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40272 if (!SWIG_IsOK(res1)) {
40273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
40274 }
40275 arg1 = reinterpret_cast< wxWindow * >(argp1);
40276 ecode2 = SWIG_AsVal_int(obj1, &val2);
40277 if (!SWIG_IsOK(ecode2)) {
40278 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
40279 }
40280 arg2 = static_cast< int >(val2);
40281 {
40282 PyThreadState* __tstate = wxPyBeginAllowThreads();
40283 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
40284 wxPyEndAllowThreads(__tstate);
40285 if (PyErr_Occurred()) SWIG_fail;
40286 }
40287 resultobj = SWIG_From_int(static_cast< int >(result));
40288 return resultobj;
40289 fail:
40290 return NULL;
40291 }
40292
40293
40294 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40295 PyObject *resultobj = 0;
40296 wxWindow *arg1 = (wxWindow *) 0 ;
40297 int arg2 ;
40298 int arg3 ;
40299 wxRect *arg4 = (wxRect *) NULL ;
40300 void *argp1 = 0 ;
40301 int res1 = 0 ;
40302 int val2 ;
40303 int ecode2 = 0 ;
40304 int val3 ;
40305 int ecode3 = 0 ;
40306 void *argp4 = 0 ;
40307 int res4 = 0 ;
40308 PyObject * obj0 = 0 ;
40309 PyObject * obj1 = 0 ;
40310 PyObject * obj2 = 0 ;
40311 PyObject * obj3 = 0 ;
40312 char * kwnames[] = {
40313 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
40314 };
40315
40316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40318 if (!SWIG_IsOK(res1)) {
40319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
40320 }
40321 arg1 = reinterpret_cast< wxWindow * >(argp1);
40322 ecode2 = SWIG_AsVal_int(obj1, &val2);
40323 if (!SWIG_IsOK(ecode2)) {
40324 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
40325 }
40326 arg2 = static_cast< int >(val2);
40327 ecode3 = SWIG_AsVal_int(obj2, &val3);
40328 if (!SWIG_IsOK(ecode3)) {
40329 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
40330 }
40331 arg3 = static_cast< int >(val3);
40332 if (obj3) {
40333 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
40334 if (!SWIG_IsOK(res4)) {
40335 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
40336 }
40337 arg4 = reinterpret_cast< wxRect * >(argp4);
40338 }
40339 {
40340 PyThreadState* __tstate = wxPyBeginAllowThreads();
40341 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
40342 wxPyEndAllowThreads(__tstate);
40343 if (PyErr_Occurred()) SWIG_fail;
40344 }
40345 resultobj = SWIG_Py_Void();
40346 return resultobj;
40347 fail:
40348 return NULL;
40349 }
40350
40351
40352 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40353 PyObject *resultobj = 0;
40354 wxWindow *arg1 = (wxWindow *) 0 ;
40355 int arg2 ;
40356 bool result;
40357 void *argp1 = 0 ;
40358 int res1 = 0 ;
40359 int val2 ;
40360 int ecode2 = 0 ;
40361 PyObject * obj0 = 0 ;
40362 PyObject * obj1 = 0 ;
40363 char * kwnames[] = {
40364 (char *) "self",(char *) "lines", NULL
40365 };
40366
40367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
40368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40369 if (!SWIG_IsOK(res1)) {
40370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
40371 }
40372 arg1 = reinterpret_cast< wxWindow * >(argp1);
40373 ecode2 = SWIG_AsVal_int(obj1, &val2);
40374 if (!SWIG_IsOK(ecode2)) {
40375 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
40376 }
40377 arg2 = static_cast< int >(val2);
40378 {
40379 PyThreadState* __tstate = wxPyBeginAllowThreads();
40380 result = (bool)(arg1)->ScrollLines(arg2);
40381 wxPyEndAllowThreads(__tstate);
40382 if (PyErr_Occurred()) SWIG_fail;
40383 }
40384 {
40385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40386 }
40387 return resultobj;
40388 fail:
40389 return NULL;
40390 }
40391
40392
40393 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40394 PyObject *resultobj = 0;
40395 wxWindow *arg1 = (wxWindow *) 0 ;
40396 int arg2 ;
40397 bool result;
40398 void *argp1 = 0 ;
40399 int res1 = 0 ;
40400 int val2 ;
40401 int ecode2 = 0 ;
40402 PyObject * obj0 = 0 ;
40403 PyObject * obj1 = 0 ;
40404 char * kwnames[] = {
40405 (char *) "self",(char *) "pages", NULL
40406 };
40407
40408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
40409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40410 if (!SWIG_IsOK(res1)) {
40411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
40412 }
40413 arg1 = reinterpret_cast< wxWindow * >(argp1);
40414 ecode2 = SWIG_AsVal_int(obj1, &val2);
40415 if (!SWIG_IsOK(ecode2)) {
40416 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
40417 }
40418 arg2 = static_cast< int >(val2);
40419 {
40420 PyThreadState* __tstate = wxPyBeginAllowThreads();
40421 result = (bool)(arg1)->ScrollPages(arg2);
40422 wxPyEndAllowThreads(__tstate);
40423 if (PyErr_Occurred()) SWIG_fail;
40424 }
40425 {
40426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40427 }
40428 return resultobj;
40429 fail:
40430 return NULL;
40431 }
40432
40433
40434 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40435 PyObject *resultobj = 0;
40436 wxWindow *arg1 = (wxWindow *) 0 ;
40437 bool result;
40438 void *argp1 = 0 ;
40439 int res1 = 0 ;
40440 PyObject *swig_obj[1] ;
40441
40442 if (!args) SWIG_fail;
40443 swig_obj[0] = args;
40444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40445 if (!SWIG_IsOK(res1)) {
40446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
40447 }
40448 arg1 = reinterpret_cast< wxWindow * >(argp1);
40449 {
40450 PyThreadState* __tstate = wxPyBeginAllowThreads();
40451 result = (bool)(arg1)->LineUp();
40452 wxPyEndAllowThreads(__tstate);
40453 if (PyErr_Occurred()) SWIG_fail;
40454 }
40455 {
40456 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40457 }
40458 return resultobj;
40459 fail:
40460 return NULL;
40461 }
40462
40463
40464 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40465 PyObject *resultobj = 0;
40466 wxWindow *arg1 = (wxWindow *) 0 ;
40467 bool result;
40468 void *argp1 = 0 ;
40469 int res1 = 0 ;
40470 PyObject *swig_obj[1] ;
40471
40472 if (!args) SWIG_fail;
40473 swig_obj[0] = args;
40474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40475 if (!SWIG_IsOK(res1)) {
40476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
40477 }
40478 arg1 = reinterpret_cast< wxWindow * >(argp1);
40479 {
40480 PyThreadState* __tstate = wxPyBeginAllowThreads();
40481 result = (bool)(arg1)->LineDown();
40482 wxPyEndAllowThreads(__tstate);
40483 if (PyErr_Occurred()) SWIG_fail;
40484 }
40485 {
40486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40487 }
40488 return resultobj;
40489 fail:
40490 return NULL;
40491 }
40492
40493
40494 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40495 PyObject *resultobj = 0;
40496 wxWindow *arg1 = (wxWindow *) 0 ;
40497 bool result;
40498 void *argp1 = 0 ;
40499 int res1 = 0 ;
40500 PyObject *swig_obj[1] ;
40501
40502 if (!args) SWIG_fail;
40503 swig_obj[0] = args;
40504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40505 if (!SWIG_IsOK(res1)) {
40506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
40507 }
40508 arg1 = reinterpret_cast< wxWindow * >(argp1);
40509 {
40510 PyThreadState* __tstate = wxPyBeginAllowThreads();
40511 result = (bool)(arg1)->PageUp();
40512 wxPyEndAllowThreads(__tstate);
40513 if (PyErr_Occurred()) SWIG_fail;
40514 }
40515 {
40516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40517 }
40518 return resultobj;
40519 fail:
40520 return NULL;
40521 }
40522
40523
40524 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40525 PyObject *resultobj = 0;
40526 wxWindow *arg1 = (wxWindow *) 0 ;
40527 bool result;
40528 void *argp1 = 0 ;
40529 int res1 = 0 ;
40530 PyObject *swig_obj[1] ;
40531
40532 if (!args) SWIG_fail;
40533 swig_obj[0] = args;
40534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40535 if (!SWIG_IsOK(res1)) {
40536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
40537 }
40538 arg1 = reinterpret_cast< wxWindow * >(argp1);
40539 {
40540 PyThreadState* __tstate = wxPyBeginAllowThreads();
40541 result = (bool)(arg1)->PageDown();
40542 wxPyEndAllowThreads(__tstate);
40543 if (PyErr_Occurred()) SWIG_fail;
40544 }
40545 {
40546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40547 }
40548 return resultobj;
40549 fail:
40550 return NULL;
40551 }
40552
40553
40554 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40555 PyObject *resultobj = 0;
40556 wxWindow *arg1 = (wxWindow *) 0 ;
40557 wxString *arg2 = 0 ;
40558 void *argp1 = 0 ;
40559 int res1 = 0 ;
40560 bool temp2 = false ;
40561 PyObject * obj0 = 0 ;
40562 PyObject * obj1 = 0 ;
40563 char * kwnames[] = {
40564 (char *) "self",(char *) "text", NULL
40565 };
40566
40567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
40568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40569 if (!SWIG_IsOK(res1)) {
40570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
40571 }
40572 arg1 = reinterpret_cast< wxWindow * >(argp1);
40573 {
40574 arg2 = wxString_in_helper(obj1);
40575 if (arg2 == NULL) SWIG_fail;
40576 temp2 = true;
40577 }
40578 {
40579 PyThreadState* __tstate = wxPyBeginAllowThreads();
40580 (arg1)->SetHelpText((wxString const &)*arg2);
40581 wxPyEndAllowThreads(__tstate);
40582 if (PyErr_Occurred()) SWIG_fail;
40583 }
40584 resultobj = SWIG_Py_Void();
40585 {
40586 if (temp2)
40587 delete arg2;
40588 }
40589 return resultobj;
40590 fail:
40591 {
40592 if (temp2)
40593 delete arg2;
40594 }
40595 return NULL;
40596 }
40597
40598
40599 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40600 PyObject *resultobj = 0;
40601 wxWindow *arg1 = (wxWindow *) 0 ;
40602 wxString *arg2 = 0 ;
40603 void *argp1 = 0 ;
40604 int res1 = 0 ;
40605 bool temp2 = false ;
40606 PyObject * obj0 = 0 ;
40607 PyObject * obj1 = 0 ;
40608 char * kwnames[] = {
40609 (char *) "self",(char *) "text", NULL
40610 };
40611
40612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
40613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40614 if (!SWIG_IsOK(res1)) {
40615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
40616 }
40617 arg1 = reinterpret_cast< wxWindow * >(argp1);
40618 {
40619 arg2 = wxString_in_helper(obj1);
40620 if (arg2 == NULL) SWIG_fail;
40621 temp2 = true;
40622 }
40623 {
40624 PyThreadState* __tstate = wxPyBeginAllowThreads();
40625 (arg1)->SetHelpTextForId((wxString const &)*arg2);
40626 wxPyEndAllowThreads(__tstate);
40627 if (PyErr_Occurred()) SWIG_fail;
40628 }
40629 resultobj = SWIG_Py_Void();
40630 {
40631 if (temp2)
40632 delete arg2;
40633 }
40634 return resultobj;
40635 fail:
40636 {
40637 if (temp2)
40638 delete arg2;
40639 }
40640 return NULL;
40641 }
40642
40643
40644 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40645 PyObject *resultobj = 0;
40646 wxWindow *arg1 = (wxWindow *) 0 ;
40647 wxPoint *arg2 = 0 ;
40648 wxHelpEvent::Origin arg3 ;
40649 wxString result;
40650 void *argp1 = 0 ;
40651 int res1 = 0 ;
40652 wxPoint temp2 ;
40653 void *argp3 ;
40654 int res3 = 0 ;
40655 PyObject * obj0 = 0 ;
40656 PyObject * obj1 = 0 ;
40657 PyObject * obj2 = 0 ;
40658 char * kwnames[] = {
40659 (char *) "self",(char *) "pt",(char *) "origin", NULL
40660 };
40661
40662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40664 if (!SWIG_IsOK(res1)) {
40665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
40666 }
40667 arg1 = reinterpret_cast< wxWindow * >(argp1);
40668 {
40669 arg2 = &temp2;
40670 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
40671 }
40672 {
40673 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
40674 if (!SWIG_IsOK(res3)) {
40675 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
40676 }
40677 if (!argp3) {
40678 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
40679 } else {
40680 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
40681 arg3 = *temp;
40682 if (SWIG_IsNewObj(res3)) delete temp;
40683 }
40684 }
40685 {
40686 PyThreadState* __tstate = wxPyBeginAllowThreads();
40687 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
40688 wxPyEndAllowThreads(__tstate);
40689 if (PyErr_Occurred()) SWIG_fail;
40690 }
40691 {
40692 #if wxUSE_UNICODE
40693 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40694 #else
40695 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40696 #endif
40697 }
40698 return resultobj;
40699 fail:
40700 return NULL;
40701 }
40702
40703
40704 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40705 PyObject *resultobj = 0;
40706 wxWindow *arg1 = (wxWindow *) 0 ;
40707 wxString result;
40708 void *argp1 = 0 ;
40709 int res1 = 0 ;
40710 PyObject *swig_obj[1] ;
40711
40712 if (!args) SWIG_fail;
40713 swig_obj[0] = args;
40714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40715 if (!SWIG_IsOK(res1)) {
40716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
40717 }
40718 arg1 = reinterpret_cast< wxWindow * >(argp1);
40719 {
40720 PyThreadState* __tstate = wxPyBeginAllowThreads();
40721 result = ((wxWindow const *)arg1)->GetHelpText();
40722 wxPyEndAllowThreads(__tstate);
40723 if (PyErr_Occurred()) SWIG_fail;
40724 }
40725 {
40726 #if wxUSE_UNICODE
40727 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40728 #else
40729 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40730 #endif
40731 }
40732 return resultobj;
40733 fail:
40734 return NULL;
40735 }
40736
40737
40738 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40739 PyObject *resultobj = 0;
40740 wxWindow *arg1 = (wxWindow *) 0 ;
40741 wxString *arg2 = 0 ;
40742 void *argp1 = 0 ;
40743 int res1 = 0 ;
40744 bool temp2 = false ;
40745 PyObject * obj0 = 0 ;
40746 PyObject * obj1 = 0 ;
40747 char * kwnames[] = {
40748 (char *) "self",(char *) "tip", NULL
40749 };
40750
40751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
40752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40753 if (!SWIG_IsOK(res1)) {
40754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
40755 }
40756 arg1 = reinterpret_cast< wxWindow * >(argp1);
40757 {
40758 arg2 = wxString_in_helper(obj1);
40759 if (arg2 == NULL) SWIG_fail;
40760 temp2 = true;
40761 }
40762 {
40763 PyThreadState* __tstate = wxPyBeginAllowThreads();
40764 (arg1)->SetToolTip((wxString const &)*arg2);
40765 wxPyEndAllowThreads(__tstate);
40766 if (PyErr_Occurred()) SWIG_fail;
40767 }
40768 resultobj = SWIG_Py_Void();
40769 {
40770 if (temp2)
40771 delete arg2;
40772 }
40773 return resultobj;
40774 fail:
40775 {
40776 if (temp2)
40777 delete arg2;
40778 }
40779 return NULL;
40780 }
40781
40782
40783 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40784 PyObject *resultobj = 0;
40785 wxWindow *arg1 = (wxWindow *) 0 ;
40786 wxToolTip *arg2 = (wxToolTip *) 0 ;
40787 void *argp1 = 0 ;
40788 int res1 = 0 ;
40789 int res2 = 0 ;
40790 PyObject * obj0 = 0 ;
40791 PyObject * obj1 = 0 ;
40792 char * kwnames[] = {
40793 (char *) "self",(char *) "tip", NULL
40794 };
40795
40796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
40797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40798 if (!SWIG_IsOK(res1)) {
40799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
40800 }
40801 arg1 = reinterpret_cast< wxWindow * >(argp1);
40802 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
40803 if (!SWIG_IsOK(res2)) {
40804 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
40805 }
40806 {
40807 PyThreadState* __tstate = wxPyBeginAllowThreads();
40808 (arg1)->SetToolTip(arg2);
40809 wxPyEndAllowThreads(__tstate);
40810 if (PyErr_Occurred()) SWIG_fail;
40811 }
40812 resultobj = SWIG_Py_Void();
40813 return resultobj;
40814 fail:
40815 return NULL;
40816 }
40817
40818
40819 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40820 PyObject *resultobj = 0;
40821 wxWindow *arg1 = (wxWindow *) 0 ;
40822 wxToolTip *result = 0 ;
40823 void *argp1 = 0 ;
40824 int res1 = 0 ;
40825 PyObject *swig_obj[1] ;
40826
40827 if (!args) SWIG_fail;
40828 swig_obj[0] = args;
40829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40830 if (!SWIG_IsOK(res1)) {
40831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
40832 }
40833 arg1 = reinterpret_cast< wxWindow * >(argp1);
40834 {
40835 PyThreadState* __tstate = wxPyBeginAllowThreads();
40836 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
40837 wxPyEndAllowThreads(__tstate);
40838 if (PyErr_Occurred()) SWIG_fail;
40839 }
40840 {
40841 resultobj = wxPyMake_wxObject(result, (bool)0);
40842 }
40843 return resultobj;
40844 fail:
40845 return NULL;
40846 }
40847
40848
40849 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40850 PyObject *resultobj = 0;
40851 wxWindow *arg1 = (wxWindow *) 0 ;
40852 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
40853 void *argp1 = 0 ;
40854 int res1 = 0 ;
40855 int res2 = 0 ;
40856 PyObject * obj0 = 0 ;
40857 PyObject * obj1 = 0 ;
40858 char * kwnames[] = {
40859 (char *) "self",(char *) "dropTarget", NULL
40860 };
40861
40862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
40863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40864 if (!SWIG_IsOK(res1)) {
40865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
40866 }
40867 arg1 = reinterpret_cast< wxWindow * >(argp1);
40868 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
40869 if (!SWIG_IsOK(res2)) {
40870 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
40871 }
40872 {
40873 PyThreadState* __tstate = wxPyBeginAllowThreads();
40874 (arg1)->SetDropTarget(arg2);
40875 wxPyEndAllowThreads(__tstate);
40876 if (PyErr_Occurred()) SWIG_fail;
40877 }
40878 resultobj = SWIG_Py_Void();
40879 return resultobj;
40880 fail:
40881 return NULL;
40882 }
40883
40884
40885 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40886 PyObject *resultobj = 0;
40887 wxWindow *arg1 = (wxWindow *) 0 ;
40888 wxPyDropTarget *result = 0 ;
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_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
40898 }
40899 arg1 = reinterpret_cast< wxWindow * >(argp1);
40900 {
40901 PyThreadState* __tstate = wxPyBeginAllowThreads();
40902 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
40903 wxPyEndAllowThreads(__tstate);
40904 if (PyErr_Occurred()) SWIG_fail;
40905 }
40906 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
40907 return resultobj;
40908 fail:
40909 return NULL;
40910 }
40911
40912
40913 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40914 PyObject *resultobj = 0;
40915 wxWindow *arg1 = (wxWindow *) 0 ;
40916 bool arg2 ;
40917 void *argp1 = 0 ;
40918 int res1 = 0 ;
40919 bool val2 ;
40920 int ecode2 = 0 ;
40921 PyObject * obj0 = 0 ;
40922 PyObject * obj1 = 0 ;
40923 char * kwnames[] = {
40924 (char *) "self",(char *) "accept", NULL
40925 };
40926
40927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
40928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40929 if (!SWIG_IsOK(res1)) {
40930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
40931 }
40932 arg1 = reinterpret_cast< wxWindow * >(argp1);
40933 ecode2 = SWIG_AsVal_bool(obj1, &val2);
40934 if (!SWIG_IsOK(ecode2)) {
40935 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
40936 }
40937 arg2 = static_cast< bool >(val2);
40938 {
40939 PyThreadState* __tstate = wxPyBeginAllowThreads();
40940 wxWindow_DragAcceptFiles(arg1,arg2);
40941 wxPyEndAllowThreads(__tstate);
40942 if (PyErr_Occurred()) SWIG_fail;
40943 }
40944 resultobj = SWIG_Py_Void();
40945 return resultobj;
40946 fail:
40947 return NULL;
40948 }
40949
40950
40951 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40952 PyObject *resultobj = 0;
40953 wxWindow *arg1 = (wxWindow *) 0 ;
40954 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
40955 void *argp1 = 0 ;
40956 int res1 = 0 ;
40957 int res2 = 0 ;
40958 PyObject * obj0 = 0 ;
40959 PyObject * obj1 = 0 ;
40960 char * kwnames[] = {
40961 (char *) "self",(char *) "constraints", NULL
40962 };
40963
40964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
40965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40966 if (!SWIG_IsOK(res1)) {
40967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
40968 }
40969 arg1 = reinterpret_cast< wxWindow * >(argp1);
40970 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
40971 if (!SWIG_IsOK(res2)) {
40972 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
40973 }
40974 {
40975 PyThreadState* __tstate = wxPyBeginAllowThreads();
40976 (arg1)->SetConstraints(arg2);
40977 wxPyEndAllowThreads(__tstate);
40978 if (PyErr_Occurred()) SWIG_fail;
40979 }
40980 resultobj = SWIG_Py_Void();
40981 return resultobj;
40982 fail:
40983 return NULL;
40984 }
40985
40986
40987 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40988 PyObject *resultobj = 0;
40989 wxWindow *arg1 = (wxWindow *) 0 ;
40990 wxLayoutConstraints *result = 0 ;
40991 void *argp1 = 0 ;
40992 int res1 = 0 ;
40993 PyObject *swig_obj[1] ;
40994
40995 if (!args) SWIG_fail;
40996 swig_obj[0] = args;
40997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40998 if (!SWIG_IsOK(res1)) {
40999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
41000 }
41001 arg1 = reinterpret_cast< wxWindow * >(argp1);
41002 {
41003 PyThreadState* __tstate = wxPyBeginAllowThreads();
41004 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
41005 wxPyEndAllowThreads(__tstate);
41006 if (PyErr_Occurred()) SWIG_fail;
41007 }
41008 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
41009 return resultobj;
41010 fail:
41011 return NULL;
41012 }
41013
41014
41015 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41016 PyObject *resultobj = 0;
41017 wxWindow *arg1 = (wxWindow *) 0 ;
41018 bool arg2 ;
41019 void *argp1 = 0 ;
41020 int res1 = 0 ;
41021 bool val2 ;
41022 int ecode2 = 0 ;
41023 PyObject * obj0 = 0 ;
41024 PyObject * obj1 = 0 ;
41025 char * kwnames[] = {
41026 (char *) "self",(char *) "autoLayout", NULL
41027 };
41028
41029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
41030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41031 if (!SWIG_IsOK(res1)) {
41032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
41033 }
41034 arg1 = reinterpret_cast< wxWindow * >(argp1);
41035 ecode2 = SWIG_AsVal_bool(obj1, &val2);
41036 if (!SWIG_IsOK(ecode2)) {
41037 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
41038 }
41039 arg2 = static_cast< bool >(val2);
41040 {
41041 PyThreadState* __tstate = wxPyBeginAllowThreads();
41042 (arg1)->SetAutoLayout(arg2);
41043 wxPyEndAllowThreads(__tstate);
41044 if (PyErr_Occurred()) SWIG_fail;
41045 }
41046 resultobj = SWIG_Py_Void();
41047 return resultobj;
41048 fail:
41049 return NULL;
41050 }
41051
41052
41053 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41054 PyObject *resultobj = 0;
41055 wxWindow *arg1 = (wxWindow *) 0 ;
41056 bool result;
41057 void *argp1 = 0 ;
41058 int res1 = 0 ;
41059 PyObject *swig_obj[1] ;
41060
41061 if (!args) SWIG_fail;
41062 swig_obj[0] = args;
41063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41064 if (!SWIG_IsOK(res1)) {
41065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
41066 }
41067 arg1 = reinterpret_cast< wxWindow * >(argp1);
41068 {
41069 PyThreadState* __tstate = wxPyBeginAllowThreads();
41070 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
41071 wxPyEndAllowThreads(__tstate);
41072 if (PyErr_Occurred()) SWIG_fail;
41073 }
41074 {
41075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41076 }
41077 return resultobj;
41078 fail:
41079 return NULL;
41080 }
41081
41082
41083 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41084 PyObject *resultobj = 0;
41085 wxWindow *arg1 = (wxWindow *) 0 ;
41086 bool result;
41087 void *argp1 = 0 ;
41088 int res1 = 0 ;
41089 PyObject *swig_obj[1] ;
41090
41091 if (!args) SWIG_fail;
41092 swig_obj[0] = args;
41093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41094 if (!SWIG_IsOK(res1)) {
41095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
41096 }
41097 arg1 = reinterpret_cast< wxWindow * >(argp1);
41098 {
41099 PyThreadState* __tstate = wxPyBeginAllowThreads();
41100 result = (bool)(arg1)->Layout();
41101 wxPyEndAllowThreads(__tstate);
41102 if (PyErr_Occurred()) SWIG_fail;
41103 }
41104 {
41105 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41106 }
41107 return resultobj;
41108 fail:
41109 return NULL;
41110 }
41111
41112
41113 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41114 PyObject *resultobj = 0;
41115 wxWindow *arg1 = (wxWindow *) 0 ;
41116 wxSizer *arg2 = (wxSizer *) 0 ;
41117 bool arg3 = (bool) true ;
41118 void *argp1 = 0 ;
41119 int res1 = 0 ;
41120 int res2 = 0 ;
41121 bool val3 ;
41122 int ecode3 = 0 ;
41123 PyObject * obj0 = 0 ;
41124 PyObject * obj1 = 0 ;
41125 PyObject * obj2 = 0 ;
41126 char * kwnames[] = {
41127 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
41128 };
41129
41130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41132 if (!SWIG_IsOK(res1)) {
41133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
41134 }
41135 arg1 = reinterpret_cast< wxWindow * >(argp1);
41136 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
41137 if (!SWIG_IsOK(res2)) {
41138 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
41139 }
41140 if (obj2) {
41141 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41142 if (!SWIG_IsOK(ecode3)) {
41143 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
41144 }
41145 arg3 = static_cast< bool >(val3);
41146 }
41147 {
41148 PyThreadState* __tstate = wxPyBeginAllowThreads();
41149 (arg1)->SetSizer(arg2,arg3);
41150 wxPyEndAllowThreads(__tstate);
41151 if (PyErr_Occurred()) SWIG_fail;
41152 }
41153 resultobj = SWIG_Py_Void();
41154 return resultobj;
41155 fail:
41156 return NULL;
41157 }
41158
41159
41160 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41161 PyObject *resultobj = 0;
41162 wxWindow *arg1 = (wxWindow *) 0 ;
41163 wxSizer *arg2 = (wxSizer *) 0 ;
41164 bool arg3 = (bool) true ;
41165 void *argp1 = 0 ;
41166 int res1 = 0 ;
41167 int res2 = 0 ;
41168 bool val3 ;
41169 int ecode3 = 0 ;
41170 PyObject * obj0 = 0 ;
41171 PyObject * obj1 = 0 ;
41172 PyObject * obj2 = 0 ;
41173 char * kwnames[] = {
41174 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
41175 };
41176
41177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41179 if (!SWIG_IsOK(res1)) {
41180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
41181 }
41182 arg1 = reinterpret_cast< wxWindow * >(argp1);
41183 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
41184 if (!SWIG_IsOK(res2)) {
41185 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
41186 }
41187 if (obj2) {
41188 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41189 if (!SWIG_IsOK(ecode3)) {
41190 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
41191 }
41192 arg3 = static_cast< bool >(val3);
41193 }
41194 {
41195 PyThreadState* __tstate = wxPyBeginAllowThreads();
41196 (arg1)->SetSizerAndFit(arg2,arg3);
41197 wxPyEndAllowThreads(__tstate);
41198 if (PyErr_Occurred()) SWIG_fail;
41199 }
41200 resultobj = SWIG_Py_Void();
41201 return resultobj;
41202 fail:
41203 return NULL;
41204 }
41205
41206
41207 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41208 PyObject *resultobj = 0;
41209 wxWindow *arg1 = (wxWindow *) 0 ;
41210 wxSizer *result = 0 ;
41211 void *argp1 = 0 ;
41212 int res1 = 0 ;
41213 PyObject *swig_obj[1] ;
41214
41215 if (!args) SWIG_fail;
41216 swig_obj[0] = args;
41217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41218 if (!SWIG_IsOK(res1)) {
41219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
41220 }
41221 arg1 = reinterpret_cast< wxWindow * >(argp1);
41222 {
41223 PyThreadState* __tstate = wxPyBeginAllowThreads();
41224 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
41225 wxPyEndAllowThreads(__tstate);
41226 if (PyErr_Occurred()) SWIG_fail;
41227 }
41228 {
41229 resultobj = wxPyMake_wxObject(result, (bool)0);
41230 }
41231 return resultobj;
41232 fail:
41233 return NULL;
41234 }
41235
41236
41237 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41238 PyObject *resultobj = 0;
41239 wxWindow *arg1 = (wxWindow *) 0 ;
41240 wxSizer *arg2 = (wxSizer *) 0 ;
41241 void *argp1 = 0 ;
41242 int res1 = 0 ;
41243 void *argp2 = 0 ;
41244 int res2 = 0 ;
41245 PyObject * obj0 = 0 ;
41246 PyObject * obj1 = 0 ;
41247 char * kwnames[] = {
41248 (char *) "self",(char *) "sizer", NULL
41249 };
41250
41251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
41252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41253 if (!SWIG_IsOK(res1)) {
41254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
41255 }
41256 arg1 = reinterpret_cast< wxWindow * >(argp1);
41257 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
41258 if (!SWIG_IsOK(res2)) {
41259 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
41260 }
41261 arg2 = reinterpret_cast< wxSizer * >(argp2);
41262 {
41263 PyThreadState* __tstate = wxPyBeginAllowThreads();
41264 (arg1)->SetContainingSizer(arg2);
41265 wxPyEndAllowThreads(__tstate);
41266 if (PyErr_Occurred()) SWIG_fail;
41267 }
41268 resultobj = SWIG_Py_Void();
41269 return resultobj;
41270 fail:
41271 return NULL;
41272 }
41273
41274
41275 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41276 PyObject *resultobj = 0;
41277 wxWindow *arg1 = (wxWindow *) 0 ;
41278 wxSizer *result = 0 ;
41279 void *argp1 = 0 ;
41280 int res1 = 0 ;
41281 PyObject *swig_obj[1] ;
41282
41283 if (!args) SWIG_fail;
41284 swig_obj[0] = args;
41285 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41286 if (!SWIG_IsOK(res1)) {
41287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
41288 }
41289 arg1 = reinterpret_cast< wxWindow * >(argp1);
41290 {
41291 PyThreadState* __tstate = wxPyBeginAllowThreads();
41292 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
41293 wxPyEndAllowThreads(__tstate);
41294 if (PyErr_Occurred()) SWIG_fail;
41295 }
41296 {
41297 resultobj = wxPyMake_wxObject(result, (bool)0);
41298 }
41299 return resultobj;
41300 fail:
41301 return NULL;
41302 }
41303
41304
41305 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41306 PyObject *resultobj = 0;
41307 wxWindow *arg1 = (wxWindow *) 0 ;
41308 void *argp1 = 0 ;
41309 int res1 = 0 ;
41310 PyObject *swig_obj[1] ;
41311
41312 if (!args) SWIG_fail;
41313 swig_obj[0] = args;
41314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41315 if (!SWIG_IsOK(res1)) {
41316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
41317 }
41318 arg1 = reinterpret_cast< wxWindow * >(argp1);
41319 {
41320 PyThreadState* __tstate = wxPyBeginAllowThreads();
41321 (arg1)->InheritAttributes();
41322 wxPyEndAllowThreads(__tstate);
41323 if (PyErr_Occurred()) SWIG_fail;
41324 }
41325 resultobj = SWIG_Py_Void();
41326 return resultobj;
41327 fail:
41328 return NULL;
41329 }
41330
41331
41332 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41333 PyObject *resultobj = 0;
41334 wxWindow *arg1 = (wxWindow *) 0 ;
41335 bool result;
41336 void *argp1 = 0 ;
41337 int res1 = 0 ;
41338 PyObject *swig_obj[1] ;
41339
41340 if (!args) SWIG_fail;
41341 swig_obj[0] = args;
41342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41343 if (!SWIG_IsOK(res1)) {
41344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
41345 }
41346 arg1 = reinterpret_cast< wxWindow * >(argp1);
41347 {
41348 PyThreadState* __tstate = wxPyBeginAllowThreads();
41349 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
41350 wxPyEndAllowThreads(__tstate);
41351 if (PyErr_Occurred()) SWIG_fail;
41352 }
41353 {
41354 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41355 }
41356 return resultobj;
41357 fail:
41358 return NULL;
41359 }
41360
41361
41362 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41363 PyObject *resultobj = 0;
41364 wxWindow *arg1 = (wxWindow *) 0 ;
41365 bool result;
41366 void *argp1 = 0 ;
41367 int res1 = 0 ;
41368 PyObject *swig_obj[1] ;
41369
41370 if (!args) SWIG_fail;
41371 swig_obj[0] = args;
41372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41373 if (!SWIG_IsOK(res1)) {
41374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
41375 }
41376 arg1 = reinterpret_cast< wxWindow * >(argp1);
41377 {
41378 PyThreadState* __tstate = wxPyBeginAllowThreads();
41379 result = (bool)(arg1)->CanSetTransparent();
41380 wxPyEndAllowThreads(__tstate);
41381 if (PyErr_Occurred()) SWIG_fail;
41382 }
41383 {
41384 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41385 }
41386 return resultobj;
41387 fail:
41388 return NULL;
41389 }
41390
41391
41392 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41393 PyObject *resultobj = 0;
41394 wxWindow *arg1 = (wxWindow *) 0 ;
41395 byte arg2 ;
41396 bool result;
41397 void *argp1 = 0 ;
41398 int res1 = 0 ;
41399 unsigned char val2 ;
41400 int ecode2 = 0 ;
41401 PyObject * obj0 = 0 ;
41402 PyObject * obj1 = 0 ;
41403 char * kwnames[] = {
41404 (char *) "self",(char *) "alpha", NULL
41405 };
41406
41407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",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_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
41411 }
41412 arg1 = reinterpret_cast< wxWindow * >(argp1);
41413 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
41414 if (!SWIG_IsOK(ecode2)) {
41415 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
41416 }
41417 arg2 = static_cast< byte >(val2);
41418 {
41419 PyThreadState* __tstate = wxPyBeginAllowThreads();
41420 result = (bool)(arg1)->SetTransparent(arg2);
41421 wxPyEndAllowThreads(__tstate);
41422 if (PyErr_Occurred()) SWIG_fail;
41423 }
41424 {
41425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41426 }
41427 return resultobj;
41428 fail:
41429 return NULL;
41430 }
41431
41432
41433 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41434 PyObject *obj;
41435 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41436 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
41437 return SWIG_Py_Void();
41438 }
41439
41440 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41441 return SWIG_Python_InitShadowInstance(args);
41442 }
41443
41444 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41445 PyObject *resultobj = 0;
41446 long arg1 ;
41447 wxWindow *arg2 = (wxWindow *) NULL ;
41448 wxWindow *result = 0 ;
41449 long val1 ;
41450 int ecode1 = 0 ;
41451 void *argp2 = 0 ;
41452 int res2 = 0 ;
41453 PyObject * obj0 = 0 ;
41454 PyObject * obj1 = 0 ;
41455 char * kwnames[] = {
41456 (char *) "id",(char *) "parent", NULL
41457 };
41458
41459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
41460 ecode1 = SWIG_AsVal_long(obj0, &val1);
41461 if (!SWIG_IsOK(ecode1)) {
41462 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
41463 }
41464 arg1 = static_cast< long >(val1);
41465 if (obj1) {
41466 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41467 if (!SWIG_IsOK(res2)) {
41468 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
41469 }
41470 arg2 = reinterpret_cast< wxWindow * >(argp2);
41471 }
41472 {
41473 if (!wxPyCheckForApp()) SWIG_fail;
41474 PyThreadState* __tstate = wxPyBeginAllowThreads();
41475 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
41476 wxPyEndAllowThreads(__tstate);
41477 if (PyErr_Occurred()) SWIG_fail;
41478 }
41479 {
41480 resultobj = wxPyMake_wxObject(result, 0);
41481 }
41482 return resultobj;
41483 fail:
41484 return NULL;
41485 }
41486
41487
41488 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41489 PyObject *resultobj = 0;
41490 wxString *arg1 = 0 ;
41491 wxWindow *arg2 = (wxWindow *) NULL ;
41492 wxWindow *result = 0 ;
41493 bool temp1 = false ;
41494 void *argp2 = 0 ;
41495 int res2 = 0 ;
41496 PyObject * obj0 = 0 ;
41497 PyObject * obj1 = 0 ;
41498 char * kwnames[] = {
41499 (char *) "name",(char *) "parent", NULL
41500 };
41501
41502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
41503 {
41504 arg1 = wxString_in_helper(obj0);
41505 if (arg1 == NULL) SWIG_fail;
41506 temp1 = true;
41507 }
41508 if (obj1) {
41509 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41510 if (!SWIG_IsOK(res2)) {
41511 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
41512 }
41513 arg2 = reinterpret_cast< wxWindow * >(argp2);
41514 }
41515 {
41516 if (!wxPyCheckForApp()) SWIG_fail;
41517 PyThreadState* __tstate = wxPyBeginAllowThreads();
41518 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
41519 wxPyEndAllowThreads(__tstate);
41520 if (PyErr_Occurred()) SWIG_fail;
41521 }
41522 {
41523 resultobj = wxPyMake_wxObject(result, 0);
41524 }
41525 {
41526 if (temp1)
41527 delete arg1;
41528 }
41529 return resultobj;
41530 fail:
41531 {
41532 if (temp1)
41533 delete arg1;
41534 }
41535 return NULL;
41536 }
41537
41538
41539 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41540 PyObject *resultobj = 0;
41541 wxString *arg1 = 0 ;
41542 wxWindow *arg2 = (wxWindow *) NULL ;
41543 wxWindow *result = 0 ;
41544 bool temp1 = false ;
41545 void *argp2 = 0 ;
41546 int res2 = 0 ;
41547 PyObject * obj0 = 0 ;
41548 PyObject * obj1 = 0 ;
41549 char * kwnames[] = {
41550 (char *) "label",(char *) "parent", NULL
41551 };
41552
41553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41554 {
41555 arg1 = wxString_in_helper(obj0);
41556 if (arg1 == NULL) SWIG_fail;
41557 temp1 = true;
41558 }
41559 if (obj1) {
41560 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41561 if (!SWIG_IsOK(res2)) {
41562 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
41563 }
41564 arg2 = reinterpret_cast< wxWindow * >(argp2);
41565 }
41566 {
41567 if (!wxPyCheckForApp()) SWIG_fail;
41568 PyThreadState* __tstate = wxPyBeginAllowThreads();
41569 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
41570 wxPyEndAllowThreads(__tstate);
41571 if (PyErr_Occurred()) SWIG_fail;
41572 }
41573 {
41574 resultobj = wxPyMake_wxObject(result, 0);
41575 }
41576 {
41577 if (temp1)
41578 delete arg1;
41579 }
41580 return resultobj;
41581 fail:
41582 {
41583 if (temp1)
41584 delete arg1;
41585 }
41586 return NULL;
41587 }
41588
41589
41590 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41591 PyObject *resultobj = 0;
41592 wxWindow *arg1 = (wxWindow *) 0 ;
41593 unsigned long arg2 ;
41594 wxWindow *result = 0 ;
41595 void *argp1 = 0 ;
41596 int res1 = 0 ;
41597 unsigned long val2 ;
41598 int ecode2 = 0 ;
41599 PyObject * obj0 = 0 ;
41600 PyObject * obj1 = 0 ;
41601 char * kwnames[] = {
41602 (char *) "parent",(char *) "_hWnd", NULL
41603 };
41604
41605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
41606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41607 if (!SWIG_IsOK(res1)) {
41608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
41609 }
41610 arg1 = reinterpret_cast< wxWindow * >(argp1);
41611 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
41612 if (!SWIG_IsOK(ecode2)) {
41613 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
41614 }
41615 arg2 = static_cast< unsigned long >(val2);
41616 {
41617 if (!wxPyCheckForApp()) SWIG_fail;
41618 PyThreadState* __tstate = wxPyBeginAllowThreads();
41619 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
41620 wxPyEndAllowThreads(__tstate);
41621 if (PyErr_Occurred()) SWIG_fail;
41622 }
41623 {
41624 resultobj = wxPyMake_wxObject(result, 0);
41625 }
41626 return resultobj;
41627 fail:
41628 return NULL;
41629 }
41630
41631
41632 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41633 PyObject *resultobj = 0;
41634 PyObject *result = 0 ;
41635
41636 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
41637 {
41638 PyThreadState* __tstate = wxPyBeginAllowThreads();
41639 result = (PyObject *)GetTopLevelWindows();
41640 wxPyEndAllowThreads(__tstate);
41641 if (PyErr_Occurred()) SWIG_fail;
41642 }
41643 resultobj = result;
41644 return resultobj;
41645 fail:
41646 return NULL;
41647 }
41648
41649
41650 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41651 PyObject *resultobj = 0;
41652 wxValidator *result = 0 ;
41653
41654 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
41655 {
41656 PyThreadState* __tstate = wxPyBeginAllowThreads();
41657 result = (wxValidator *)new wxValidator();
41658 wxPyEndAllowThreads(__tstate);
41659 if (PyErr_Occurred()) SWIG_fail;
41660 }
41661 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
41662 return resultobj;
41663 fail:
41664 return NULL;
41665 }
41666
41667
41668 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41669 PyObject *resultobj = 0;
41670 wxValidator *arg1 = (wxValidator *) 0 ;
41671 wxValidator *result = 0 ;
41672 void *argp1 = 0 ;
41673 int res1 = 0 ;
41674 PyObject *swig_obj[1] ;
41675
41676 if (!args) SWIG_fail;
41677 swig_obj[0] = args;
41678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41679 if (!SWIG_IsOK(res1)) {
41680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
41681 }
41682 arg1 = reinterpret_cast< wxValidator * >(argp1);
41683 {
41684 PyThreadState* __tstate = wxPyBeginAllowThreads();
41685 result = (wxValidator *)(arg1)->Clone();
41686 wxPyEndAllowThreads(__tstate);
41687 if (PyErr_Occurred()) SWIG_fail;
41688 }
41689 {
41690 resultobj = wxPyMake_wxObject(result, 0);
41691 }
41692 return resultobj;
41693 fail:
41694 return NULL;
41695 }
41696
41697
41698 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41699 PyObject *resultobj = 0;
41700 wxValidator *arg1 = (wxValidator *) 0 ;
41701 wxWindow *arg2 = (wxWindow *) 0 ;
41702 bool result;
41703 void *argp1 = 0 ;
41704 int res1 = 0 ;
41705 void *argp2 = 0 ;
41706 int res2 = 0 ;
41707 PyObject * obj0 = 0 ;
41708 PyObject * obj1 = 0 ;
41709 char * kwnames[] = {
41710 (char *) "self",(char *) "parent", NULL
41711 };
41712
41713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
41714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41715 if (!SWIG_IsOK(res1)) {
41716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
41717 }
41718 arg1 = reinterpret_cast< wxValidator * >(argp1);
41719 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41720 if (!SWIG_IsOK(res2)) {
41721 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
41722 }
41723 arg2 = reinterpret_cast< wxWindow * >(argp2);
41724 {
41725 PyThreadState* __tstate = wxPyBeginAllowThreads();
41726 result = (bool)(arg1)->Validate(arg2);
41727 wxPyEndAllowThreads(__tstate);
41728 if (PyErr_Occurred()) SWIG_fail;
41729 }
41730 {
41731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41732 }
41733 return resultobj;
41734 fail:
41735 return NULL;
41736 }
41737
41738
41739 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41740 PyObject *resultobj = 0;
41741 wxValidator *arg1 = (wxValidator *) 0 ;
41742 bool result;
41743 void *argp1 = 0 ;
41744 int res1 = 0 ;
41745 PyObject *swig_obj[1] ;
41746
41747 if (!args) SWIG_fail;
41748 swig_obj[0] = args;
41749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41750 if (!SWIG_IsOK(res1)) {
41751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41752 }
41753 arg1 = reinterpret_cast< wxValidator * >(argp1);
41754 {
41755 PyThreadState* __tstate = wxPyBeginAllowThreads();
41756 result = (bool)(arg1)->TransferToWindow();
41757 wxPyEndAllowThreads(__tstate);
41758 if (PyErr_Occurred()) SWIG_fail;
41759 }
41760 {
41761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41762 }
41763 return resultobj;
41764 fail:
41765 return NULL;
41766 }
41767
41768
41769 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41770 PyObject *resultobj = 0;
41771 wxValidator *arg1 = (wxValidator *) 0 ;
41772 bool result;
41773 void *argp1 = 0 ;
41774 int res1 = 0 ;
41775 PyObject *swig_obj[1] ;
41776
41777 if (!args) SWIG_fail;
41778 swig_obj[0] = args;
41779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41780 if (!SWIG_IsOK(res1)) {
41781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41782 }
41783 arg1 = reinterpret_cast< wxValidator * >(argp1);
41784 {
41785 PyThreadState* __tstate = wxPyBeginAllowThreads();
41786 result = (bool)(arg1)->TransferFromWindow();
41787 wxPyEndAllowThreads(__tstate);
41788 if (PyErr_Occurred()) SWIG_fail;
41789 }
41790 {
41791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41792 }
41793 return resultobj;
41794 fail:
41795 return NULL;
41796 }
41797
41798
41799 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41800 PyObject *resultobj = 0;
41801 wxValidator *arg1 = (wxValidator *) 0 ;
41802 wxWindow *result = 0 ;
41803 void *argp1 = 0 ;
41804 int res1 = 0 ;
41805 PyObject *swig_obj[1] ;
41806
41807 if (!args) SWIG_fail;
41808 swig_obj[0] = args;
41809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41810 if (!SWIG_IsOK(res1)) {
41811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41812 }
41813 arg1 = reinterpret_cast< wxValidator * >(argp1);
41814 {
41815 PyThreadState* __tstate = wxPyBeginAllowThreads();
41816 result = (wxWindow *)(arg1)->GetWindow();
41817 wxPyEndAllowThreads(__tstate);
41818 if (PyErr_Occurred()) SWIG_fail;
41819 }
41820 {
41821 resultobj = wxPyMake_wxObject(result, 0);
41822 }
41823 return resultobj;
41824 fail:
41825 return NULL;
41826 }
41827
41828
41829 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41830 PyObject *resultobj = 0;
41831 wxValidator *arg1 = (wxValidator *) 0 ;
41832 wxWindow *arg2 = (wxWindow *) 0 ;
41833 void *argp1 = 0 ;
41834 int res1 = 0 ;
41835 void *argp2 = 0 ;
41836 int res2 = 0 ;
41837 PyObject * obj0 = 0 ;
41838 PyObject * obj1 = 0 ;
41839 char * kwnames[] = {
41840 (char *) "self",(char *) "window", NULL
41841 };
41842
41843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
41844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41845 if (!SWIG_IsOK(res1)) {
41846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41847 }
41848 arg1 = reinterpret_cast< wxValidator * >(argp1);
41849 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41850 if (!SWIG_IsOK(res2)) {
41851 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
41852 }
41853 arg2 = reinterpret_cast< wxWindow * >(argp2);
41854 {
41855 PyThreadState* __tstate = wxPyBeginAllowThreads();
41856 (arg1)->SetWindow(arg2);
41857 wxPyEndAllowThreads(__tstate);
41858 if (PyErr_Occurred()) SWIG_fail;
41859 }
41860 resultobj = SWIG_Py_Void();
41861 return resultobj;
41862 fail:
41863 return NULL;
41864 }
41865
41866
41867 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41868 PyObject *resultobj = 0;
41869 bool result;
41870
41871 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
41872 {
41873 PyThreadState* __tstate = wxPyBeginAllowThreads();
41874 result = (bool)wxValidator::IsSilent();
41875 wxPyEndAllowThreads(__tstate);
41876 if (PyErr_Occurred()) SWIG_fail;
41877 }
41878 {
41879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41880 }
41881 return resultobj;
41882 fail:
41883 return NULL;
41884 }
41885
41886
41887 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41888 PyObject *resultobj = 0;
41889 int arg1 = (int) true ;
41890 int val1 ;
41891 int ecode1 = 0 ;
41892 PyObject * obj0 = 0 ;
41893 char * kwnames[] = {
41894 (char *) "doIt", NULL
41895 };
41896
41897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
41898 if (obj0) {
41899 ecode1 = SWIG_AsVal_int(obj0, &val1);
41900 if (!SWIG_IsOK(ecode1)) {
41901 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
41902 }
41903 arg1 = static_cast< int >(val1);
41904 }
41905 {
41906 PyThreadState* __tstate = wxPyBeginAllowThreads();
41907 wxValidator::SetBellOnError(arg1);
41908 wxPyEndAllowThreads(__tstate);
41909 if (PyErr_Occurred()) SWIG_fail;
41910 }
41911 resultobj = SWIG_Py_Void();
41912 return resultobj;
41913 fail:
41914 return NULL;
41915 }
41916
41917
41918 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41919 PyObject *obj;
41920 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41921 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
41922 return SWIG_Py_Void();
41923 }
41924
41925 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41926 return SWIG_Python_InitShadowInstance(args);
41927 }
41928
41929 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41930 PyObject *resultobj = 0;
41931 wxPyValidator *result = 0 ;
41932
41933 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
41934 {
41935 PyThreadState* __tstate = wxPyBeginAllowThreads();
41936 result = (wxPyValidator *)new wxPyValidator();
41937 wxPyEndAllowThreads(__tstate);
41938 if (PyErr_Occurred()) SWIG_fail;
41939 }
41940 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
41941 return resultobj;
41942 fail:
41943 return NULL;
41944 }
41945
41946
41947 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41948 PyObject *resultobj = 0;
41949 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
41950 PyObject *arg2 = (PyObject *) 0 ;
41951 PyObject *arg3 = (PyObject *) 0 ;
41952 int arg4 = (int) 1 ;
41953 void *argp1 = 0 ;
41954 int res1 = 0 ;
41955 int val4 ;
41956 int ecode4 = 0 ;
41957 PyObject * obj0 = 0 ;
41958 PyObject * obj1 = 0 ;
41959 PyObject * obj2 = 0 ;
41960 PyObject * obj3 = 0 ;
41961 char * kwnames[] = {
41962 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
41963 };
41964
41965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
41967 if (!SWIG_IsOK(res1)) {
41968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
41969 }
41970 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
41971 arg2 = obj1;
41972 arg3 = obj2;
41973 if (obj3) {
41974 ecode4 = SWIG_AsVal_int(obj3, &val4);
41975 if (!SWIG_IsOK(ecode4)) {
41976 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
41977 }
41978 arg4 = static_cast< int >(val4);
41979 }
41980 {
41981 PyThreadState* __tstate = wxPyBeginAllowThreads();
41982 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
41983 wxPyEndAllowThreads(__tstate);
41984 if (PyErr_Occurred()) SWIG_fail;
41985 }
41986 resultobj = SWIG_Py_Void();
41987 return resultobj;
41988 fail:
41989 return NULL;
41990 }
41991
41992
41993 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41994 PyObject *obj;
41995 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41996 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
41997 return SWIG_Py_Void();
41998 }
41999
42000 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42001 return SWIG_Python_InitShadowInstance(args);
42002 }
42003
42004 SWIGINTERN int DefaultValidator_set(PyObject *) {
42005 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
42006 return 1;
42007 }
42008
42009
42010 SWIGINTERN PyObject *DefaultValidator_get(void) {
42011 PyObject *pyobj = 0;
42012
42013 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
42014 return pyobj;
42015 }
42016
42017
42018 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42019 PyObject *resultobj = 0;
42020 wxString const &arg1_defvalue = wxPyEmptyString ;
42021 wxString *arg1 = (wxString *) &arg1_defvalue ;
42022 long arg2 = (long) 0 ;
42023 wxMenu *result = 0 ;
42024 bool temp1 = false ;
42025 long val2 ;
42026 int ecode2 = 0 ;
42027 PyObject * obj0 = 0 ;
42028 PyObject * obj1 = 0 ;
42029 char * kwnames[] = {
42030 (char *) "title",(char *) "style", NULL
42031 };
42032
42033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
42034 if (obj0) {
42035 {
42036 arg1 = wxString_in_helper(obj0);
42037 if (arg1 == NULL) SWIG_fail;
42038 temp1 = true;
42039 }
42040 }
42041 if (obj1) {
42042 ecode2 = SWIG_AsVal_long(obj1, &val2);
42043 if (!SWIG_IsOK(ecode2)) {
42044 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
42045 }
42046 arg2 = static_cast< long >(val2);
42047 }
42048 {
42049 if (!wxPyCheckForApp()) SWIG_fail;
42050 PyThreadState* __tstate = wxPyBeginAllowThreads();
42051 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
42052 wxPyEndAllowThreads(__tstate);
42053 if (PyErr_Occurred()) SWIG_fail;
42054 }
42055 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
42056 {
42057 if (temp1)
42058 delete arg1;
42059 }
42060 return resultobj;
42061 fail:
42062 {
42063 if (temp1)
42064 delete arg1;
42065 }
42066 return NULL;
42067 }
42068
42069
42070 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42071 PyObject *resultobj = 0;
42072 wxMenu *arg1 = (wxMenu *) 0 ;
42073 int arg2 ;
42074 wxString const &arg3_defvalue = wxPyEmptyString ;
42075 wxString *arg3 = (wxString *) &arg3_defvalue ;
42076 wxString const &arg4_defvalue = wxPyEmptyString ;
42077 wxString *arg4 = (wxString *) &arg4_defvalue ;
42078 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42079 wxMenuItem *result = 0 ;
42080 void *argp1 = 0 ;
42081 int res1 = 0 ;
42082 int val2 ;
42083 int ecode2 = 0 ;
42084 bool temp3 = false ;
42085 bool temp4 = false ;
42086 int val5 ;
42087 int ecode5 = 0 ;
42088 PyObject * obj0 = 0 ;
42089 PyObject * obj1 = 0 ;
42090 PyObject * obj2 = 0 ;
42091 PyObject * obj3 = 0 ;
42092 PyObject * obj4 = 0 ;
42093 char * kwnames[] = {
42094 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
42095 };
42096
42097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42099 if (!SWIG_IsOK(res1)) {
42100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
42101 }
42102 arg1 = reinterpret_cast< wxMenu * >(argp1);
42103 ecode2 = SWIG_AsVal_int(obj1, &val2);
42104 if (!SWIG_IsOK(ecode2)) {
42105 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
42106 }
42107 arg2 = static_cast< int >(val2);
42108 if (obj2) {
42109 {
42110 arg3 = wxString_in_helper(obj2);
42111 if (arg3 == NULL) SWIG_fail;
42112 temp3 = true;
42113 }
42114 }
42115 if (obj3) {
42116 {
42117 arg4 = wxString_in_helper(obj3);
42118 if (arg4 == NULL) SWIG_fail;
42119 temp4 = true;
42120 }
42121 }
42122 if (obj4) {
42123 ecode5 = SWIG_AsVal_int(obj4, &val5);
42124 if (!SWIG_IsOK(ecode5)) {
42125 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
42126 }
42127 arg5 = static_cast< wxItemKind >(val5);
42128 }
42129 {
42130 PyThreadState* __tstate = wxPyBeginAllowThreads();
42131 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
42132 wxPyEndAllowThreads(__tstate);
42133 if (PyErr_Occurred()) SWIG_fail;
42134 }
42135 {
42136 resultobj = wxPyMake_wxObject(result, (bool)0);
42137 }
42138 {
42139 if (temp3)
42140 delete arg3;
42141 }
42142 {
42143 if (temp4)
42144 delete arg4;
42145 }
42146 return resultobj;
42147 fail:
42148 {
42149 if (temp3)
42150 delete arg3;
42151 }
42152 {
42153 if (temp4)
42154 delete arg4;
42155 }
42156 return NULL;
42157 }
42158
42159
42160 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42161 PyObject *resultobj = 0;
42162 wxMenu *arg1 = (wxMenu *) 0 ;
42163 wxMenuItem *result = 0 ;
42164 void *argp1 = 0 ;
42165 int res1 = 0 ;
42166 PyObject *swig_obj[1] ;
42167
42168 if (!args) SWIG_fail;
42169 swig_obj[0] = args;
42170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42171 if (!SWIG_IsOK(res1)) {
42172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42173 }
42174 arg1 = reinterpret_cast< wxMenu * >(argp1);
42175 {
42176 PyThreadState* __tstate = wxPyBeginAllowThreads();
42177 result = (wxMenuItem *)(arg1)->AppendSeparator();
42178 wxPyEndAllowThreads(__tstate);
42179 if (PyErr_Occurred()) SWIG_fail;
42180 }
42181 {
42182 resultobj = wxPyMake_wxObject(result, (bool)0);
42183 }
42184 return resultobj;
42185 fail:
42186 return NULL;
42187 }
42188
42189
42190 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42191 PyObject *resultobj = 0;
42192 wxMenu *arg1 = (wxMenu *) 0 ;
42193 int arg2 ;
42194 wxString *arg3 = 0 ;
42195 wxString const &arg4_defvalue = wxPyEmptyString ;
42196 wxString *arg4 = (wxString *) &arg4_defvalue ;
42197 wxMenuItem *result = 0 ;
42198 void *argp1 = 0 ;
42199 int res1 = 0 ;
42200 int val2 ;
42201 int ecode2 = 0 ;
42202 bool temp3 = false ;
42203 bool temp4 = false ;
42204 PyObject * obj0 = 0 ;
42205 PyObject * obj1 = 0 ;
42206 PyObject * obj2 = 0 ;
42207 PyObject * obj3 = 0 ;
42208 char * kwnames[] = {
42209 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42210 };
42211
42212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42214 if (!SWIG_IsOK(res1)) {
42215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42216 }
42217 arg1 = reinterpret_cast< wxMenu * >(argp1);
42218 ecode2 = SWIG_AsVal_int(obj1, &val2);
42219 if (!SWIG_IsOK(ecode2)) {
42220 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
42221 }
42222 arg2 = static_cast< int >(val2);
42223 {
42224 arg3 = wxString_in_helper(obj2);
42225 if (arg3 == NULL) SWIG_fail;
42226 temp3 = true;
42227 }
42228 if (obj3) {
42229 {
42230 arg4 = wxString_in_helper(obj3);
42231 if (arg4 == NULL) SWIG_fail;
42232 temp4 = true;
42233 }
42234 }
42235 {
42236 PyThreadState* __tstate = wxPyBeginAllowThreads();
42237 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42238 wxPyEndAllowThreads(__tstate);
42239 if (PyErr_Occurred()) SWIG_fail;
42240 }
42241 {
42242 resultobj = wxPyMake_wxObject(result, (bool)0);
42243 }
42244 {
42245 if (temp3)
42246 delete arg3;
42247 }
42248 {
42249 if (temp4)
42250 delete arg4;
42251 }
42252 return resultobj;
42253 fail:
42254 {
42255 if (temp3)
42256 delete arg3;
42257 }
42258 {
42259 if (temp4)
42260 delete arg4;
42261 }
42262 return NULL;
42263 }
42264
42265
42266 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42267 PyObject *resultobj = 0;
42268 wxMenu *arg1 = (wxMenu *) 0 ;
42269 int arg2 ;
42270 wxString *arg3 = 0 ;
42271 wxString const &arg4_defvalue = wxPyEmptyString ;
42272 wxString *arg4 = (wxString *) &arg4_defvalue ;
42273 wxMenuItem *result = 0 ;
42274 void *argp1 = 0 ;
42275 int res1 = 0 ;
42276 int val2 ;
42277 int ecode2 = 0 ;
42278 bool temp3 = false ;
42279 bool temp4 = false ;
42280 PyObject * obj0 = 0 ;
42281 PyObject * obj1 = 0 ;
42282 PyObject * obj2 = 0 ;
42283 PyObject * obj3 = 0 ;
42284 char * kwnames[] = {
42285 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42286 };
42287
42288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42290 if (!SWIG_IsOK(res1)) {
42291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42292 }
42293 arg1 = reinterpret_cast< wxMenu * >(argp1);
42294 ecode2 = SWIG_AsVal_int(obj1, &val2);
42295 if (!SWIG_IsOK(ecode2)) {
42296 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
42297 }
42298 arg2 = static_cast< int >(val2);
42299 {
42300 arg3 = wxString_in_helper(obj2);
42301 if (arg3 == NULL) SWIG_fail;
42302 temp3 = true;
42303 }
42304 if (obj3) {
42305 {
42306 arg4 = wxString_in_helper(obj3);
42307 if (arg4 == NULL) SWIG_fail;
42308 temp4 = true;
42309 }
42310 }
42311 {
42312 PyThreadState* __tstate = wxPyBeginAllowThreads();
42313 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42314 wxPyEndAllowThreads(__tstate);
42315 if (PyErr_Occurred()) SWIG_fail;
42316 }
42317 {
42318 resultobj = wxPyMake_wxObject(result, (bool)0);
42319 }
42320 {
42321 if (temp3)
42322 delete arg3;
42323 }
42324 {
42325 if (temp4)
42326 delete arg4;
42327 }
42328 return resultobj;
42329 fail:
42330 {
42331 if (temp3)
42332 delete arg3;
42333 }
42334 {
42335 if (temp4)
42336 delete arg4;
42337 }
42338 return NULL;
42339 }
42340
42341
42342 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42343 PyObject *resultobj = 0;
42344 wxMenu *arg1 = (wxMenu *) 0 ;
42345 int arg2 ;
42346 wxString *arg3 = 0 ;
42347 wxMenu *arg4 = (wxMenu *) 0 ;
42348 wxString const &arg5_defvalue = wxPyEmptyString ;
42349 wxString *arg5 = (wxString *) &arg5_defvalue ;
42350 wxMenuItem *result = 0 ;
42351 void *argp1 = 0 ;
42352 int res1 = 0 ;
42353 int val2 ;
42354 int ecode2 = 0 ;
42355 bool temp3 = false ;
42356 void *argp4 = 0 ;
42357 int res4 = 0 ;
42358 bool temp5 = false ;
42359 PyObject * obj0 = 0 ;
42360 PyObject * obj1 = 0 ;
42361 PyObject * obj2 = 0 ;
42362 PyObject * obj3 = 0 ;
42363 PyObject * obj4 = 0 ;
42364 char * kwnames[] = {
42365 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
42366 };
42367
42368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42370 if (!SWIG_IsOK(res1)) {
42371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42372 }
42373 arg1 = reinterpret_cast< wxMenu * >(argp1);
42374 ecode2 = SWIG_AsVal_int(obj1, &val2);
42375 if (!SWIG_IsOK(ecode2)) {
42376 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
42377 }
42378 arg2 = static_cast< int >(val2);
42379 {
42380 arg3 = wxString_in_helper(obj2);
42381 if (arg3 == NULL) SWIG_fail;
42382 temp3 = true;
42383 }
42384 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
42385 if (!SWIG_IsOK(res4)) {
42386 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
42387 }
42388 arg4 = reinterpret_cast< wxMenu * >(argp4);
42389 if (obj4) {
42390 {
42391 arg5 = wxString_in_helper(obj4);
42392 if (arg5 == NULL) SWIG_fail;
42393 temp5 = true;
42394 }
42395 }
42396 {
42397 PyThreadState* __tstate = wxPyBeginAllowThreads();
42398 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
42399 wxPyEndAllowThreads(__tstate);
42400 if (PyErr_Occurred()) SWIG_fail;
42401 }
42402 {
42403 resultobj = wxPyMake_wxObject(result, (bool)0);
42404 }
42405 {
42406 if (temp3)
42407 delete arg3;
42408 }
42409 {
42410 if (temp5)
42411 delete arg5;
42412 }
42413 return resultobj;
42414 fail:
42415 {
42416 if (temp3)
42417 delete arg3;
42418 }
42419 {
42420 if (temp5)
42421 delete arg5;
42422 }
42423 return NULL;
42424 }
42425
42426
42427 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42428 PyObject *resultobj = 0;
42429 wxMenu *arg1 = (wxMenu *) 0 ;
42430 wxMenu *arg2 = (wxMenu *) 0 ;
42431 wxString *arg3 = 0 ;
42432 wxString const &arg4_defvalue = wxPyEmptyString ;
42433 wxString *arg4 = (wxString *) &arg4_defvalue ;
42434 wxMenuItem *result = 0 ;
42435 void *argp1 = 0 ;
42436 int res1 = 0 ;
42437 void *argp2 = 0 ;
42438 int res2 = 0 ;
42439 bool temp3 = false ;
42440 bool temp4 = false ;
42441 PyObject * obj0 = 0 ;
42442 PyObject * obj1 = 0 ;
42443 PyObject * obj2 = 0 ;
42444 PyObject * obj3 = 0 ;
42445 char * kwnames[] = {
42446 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
42447 };
42448
42449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42451 if (!SWIG_IsOK(res1)) {
42452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42453 }
42454 arg1 = reinterpret_cast< wxMenu * >(argp1);
42455 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42456 if (!SWIG_IsOK(res2)) {
42457 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42458 }
42459 arg2 = reinterpret_cast< wxMenu * >(argp2);
42460 {
42461 arg3 = wxString_in_helper(obj2);
42462 if (arg3 == NULL) SWIG_fail;
42463 temp3 = true;
42464 }
42465 if (obj3) {
42466 {
42467 arg4 = wxString_in_helper(obj3);
42468 if (arg4 == NULL) SWIG_fail;
42469 temp4 = true;
42470 }
42471 }
42472 {
42473 PyThreadState* __tstate = wxPyBeginAllowThreads();
42474 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42475 wxPyEndAllowThreads(__tstate);
42476 if (PyErr_Occurred()) SWIG_fail;
42477 }
42478 {
42479 resultobj = wxPyMake_wxObject(result, (bool)0);
42480 }
42481 {
42482 if (temp3)
42483 delete arg3;
42484 }
42485 {
42486 if (temp4)
42487 delete arg4;
42488 }
42489 return resultobj;
42490 fail:
42491 {
42492 if (temp3)
42493 delete arg3;
42494 }
42495 {
42496 if (temp4)
42497 delete arg4;
42498 }
42499 return NULL;
42500 }
42501
42502
42503 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42504 PyObject *resultobj = 0;
42505 wxMenu *arg1 = (wxMenu *) 0 ;
42506 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
42507 wxMenuItem *result = 0 ;
42508 void *argp1 = 0 ;
42509 int res1 = 0 ;
42510 int res2 = 0 ;
42511 PyObject * obj0 = 0 ;
42512 PyObject * obj1 = 0 ;
42513 char * kwnames[] = {
42514 (char *) "self",(char *) "item", NULL
42515 };
42516
42517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
42518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42519 if (!SWIG_IsOK(res1)) {
42520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42521 }
42522 arg1 = reinterpret_cast< wxMenu * >(argp1);
42523 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42524 if (!SWIG_IsOK(res2)) {
42525 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
42526 }
42527 {
42528 PyThreadState* __tstate = wxPyBeginAllowThreads();
42529 result = (wxMenuItem *)(arg1)->Append(arg2);
42530 wxPyEndAllowThreads(__tstate);
42531 if (PyErr_Occurred()) SWIG_fail;
42532 }
42533 {
42534 resultobj = wxPyMake_wxObject(result, (bool)0);
42535 }
42536 return resultobj;
42537 fail:
42538 return NULL;
42539 }
42540
42541
42542 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42543 PyObject *resultobj = 0;
42544 wxMenu *arg1 = (wxMenu *) 0 ;
42545 size_t arg2 ;
42546 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
42547 wxMenuItem *result = 0 ;
42548 void *argp1 = 0 ;
42549 int res1 = 0 ;
42550 size_t val2 ;
42551 int ecode2 = 0 ;
42552 int res3 = 0 ;
42553 PyObject * obj0 = 0 ;
42554 PyObject * obj1 = 0 ;
42555 PyObject * obj2 = 0 ;
42556 char * kwnames[] = {
42557 (char *) "self",(char *) "pos",(char *) "item", NULL
42558 };
42559
42560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42562 if (!SWIG_IsOK(res1)) {
42563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42564 }
42565 arg1 = reinterpret_cast< wxMenu * >(argp1);
42566 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42567 if (!SWIG_IsOK(ecode2)) {
42568 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
42569 }
42570 arg2 = static_cast< size_t >(val2);
42571 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42572 if (!SWIG_IsOK(res3)) {
42573 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
42574 }
42575 {
42576 PyThreadState* __tstate = wxPyBeginAllowThreads();
42577 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
42578 wxPyEndAllowThreads(__tstate);
42579 if (PyErr_Occurred()) SWIG_fail;
42580 }
42581 {
42582 resultobj = wxPyMake_wxObject(result, (bool)0);
42583 }
42584 return resultobj;
42585 fail:
42586 return NULL;
42587 }
42588
42589
42590 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42591 PyObject *resultobj = 0;
42592 wxMenu *arg1 = (wxMenu *) 0 ;
42593 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
42594 wxMenuItem *result = 0 ;
42595 void *argp1 = 0 ;
42596 int res1 = 0 ;
42597 int res2 = 0 ;
42598 PyObject * obj0 = 0 ;
42599 PyObject * obj1 = 0 ;
42600 char * kwnames[] = {
42601 (char *) "self",(char *) "item", NULL
42602 };
42603
42604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
42605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42606 if (!SWIG_IsOK(res1)) {
42607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42608 }
42609 arg1 = reinterpret_cast< wxMenu * >(argp1);
42610 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42611 if (!SWIG_IsOK(res2)) {
42612 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
42613 }
42614 {
42615 PyThreadState* __tstate = wxPyBeginAllowThreads();
42616 result = (wxMenuItem *)(arg1)->Prepend(arg2);
42617 wxPyEndAllowThreads(__tstate);
42618 if (PyErr_Occurred()) SWIG_fail;
42619 }
42620 {
42621 resultobj = wxPyMake_wxObject(result, (bool)0);
42622 }
42623 return resultobj;
42624 fail:
42625 return NULL;
42626 }
42627
42628
42629 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42630 PyObject *resultobj = 0;
42631 wxMenu *arg1 = (wxMenu *) 0 ;
42632 void *argp1 = 0 ;
42633 int res1 = 0 ;
42634 PyObject *swig_obj[1] ;
42635
42636 if (!args) SWIG_fail;
42637 swig_obj[0] = args;
42638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42639 if (!SWIG_IsOK(res1)) {
42640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
42641 }
42642 arg1 = reinterpret_cast< wxMenu * >(argp1);
42643 {
42644 PyThreadState* __tstate = wxPyBeginAllowThreads();
42645 (arg1)->Break();
42646 wxPyEndAllowThreads(__tstate);
42647 if (PyErr_Occurred()) SWIG_fail;
42648 }
42649 resultobj = SWIG_Py_Void();
42650 return resultobj;
42651 fail:
42652 return NULL;
42653 }
42654
42655
42656 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42657 PyObject *resultobj = 0;
42658 wxMenu *arg1 = (wxMenu *) 0 ;
42659 size_t arg2 ;
42660 int arg3 ;
42661 wxString const &arg4_defvalue = wxPyEmptyString ;
42662 wxString *arg4 = (wxString *) &arg4_defvalue ;
42663 wxString const &arg5_defvalue = wxPyEmptyString ;
42664 wxString *arg5 = (wxString *) &arg5_defvalue ;
42665 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
42666 wxMenuItem *result = 0 ;
42667 void *argp1 = 0 ;
42668 int res1 = 0 ;
42669 size_t val2 ;
42670 int ecode2 = 0 ;
42671 int val3 ;
42672 int ecode3 = 0 ;
42673 bool temp4 = false ;
42674 bool temp5 = false ;
42675 int val6 ;
42676 int ecode6 = 0 ;
42677 PyObject * obj0 = 0 ;
42678 PyObject * obj1 = 0 ;
42679 PyObject * obj2 = 0 ;
42680 PyObject * obj3 = 0 ;
42681 PyObject * obj4 = 0 ;
42682 PyObject * obj5 = 0 ;
42683 char * kwnames[] = {
42684 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
42685 };
42686
42687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42689 if (!SWIG_IsOK(res1)) {
42690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
42691 }
42692 arg1 = reinterpret_cast< wxMenu * >(argp1);
42693 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42694 if (!SWIG_IsOK(ecode2)) {
42695 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
42696 }
42697 arg2 = static_cast< size_t >(val2);
42698 ecode3 = SWIG_AsVal_int(obj2, &val3);
42699 if (!SWIG_IsOK(ecode3)) {
42700 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
42701 }
42702 arg3 = static_cast< int >(val3);
42703 if (obj3) {
42704 {
42705 arg4 = wxString_in_helper(obj3);
42706 if (arg4 == NULL) SWIG_fail;
42707 temp4 = true;
42708 }
42709 }
42710 if (obj4) {
42711 {
42712 arg5 = wxString_in_helper(obj4);
42713 if (arg5 == NULL) SWIG_fail;
42714 temp5 = true;
42715 }
42716 }
42717 if (obj5) {
42718 ecode6 = SWIG_AsVal_int(obj5, &val6);
42719 if (!SWIG_IsOK(ecode6)) {
42720 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
42721 }
42722 arg6 = static_cast< wxItemKind >(val6);
42723 }
42724 {
42725 PyThreadState* __tstate = wxPyBeginAllowThreads();
42726 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
42727 wxPyEndAllowThreads(__tstate);
42728 if (PyErr_Occurred()) SWIG_fail;
42729 }
42730 {
42731 resultobj = wxPyMake_wxObject(result, (bool)0);
42732 }
42733 {
42734 if (temp4)
42735 delete arg4;
42736 }
42737 {
42738 if (temp5)
42739 delete arg5;
42740 }
42741 return resultobj;
42742 fail:
42743 {
42744 if (temp4)
42745 delete arg4;
42746 }
42747 {
42748 if (temp5)
42749 delete arg5;
42750 }
42751 return NULL;
42752 }
42753
42754
42755 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42756 PyObject *resultobj = 0;
42757 wxMenu *arg1 = (wxMenu *) 0 ;
42758 size_t arg2 ;
42759 wxMenuItem *result = 0 ;
42760 void *argp1 = 0 ;
42761 int res1 = 0 ;
42762 size_t val2 ;
42763 int ecode2 = 0 ;
42764 PyObject * obj0 = 0 ;
42765 PyObject * obj1 = 0 ;
42766 char * kwnames[] = {
42767 (char *) "self",(char *) "pos", NULL
42768 };
42769
42770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
42771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42772 if (!SWIG_IsOK(res1)) {
42773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42774 }
42775 arg1 = reinterpret_cast< wxMenu * >(argp1);
42776 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42777 if (!SWIG_IsOK(ecode2)) {
42778 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
42779 }
42780 arg2 = static_cast< size_t >(val2);
42781 {
42782 PyThreadState* __tstate = wxPyBeginAllowThreads();
42783 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
42784 wxPyEndAllowThreads(__tstate);
42785 if (PyErr_Occurred()) SWIG_fail;
42786 }
42787 {
42788 resultobj = wxPyMake_wxObject(result, (bool)0);
42789 }
42790 return resultobj;
42791 fail:
42792 return NULL;
42793 }
42794
42795
42796 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42797 PyObject *resultobj = 0;
42798 wxMenu *arg1 = (wxMenu *) 0 ;
42799 size_t arg2 ;
42800 int arg3 ;
42801 wxString *arg4 = 0 ;
42802 wxString const &arg5_defvalue = wxPyEmptyString ;
42803 wxString *arg5 = (wxString *) &arg5_defvalue ;
42804 wxMenuItem *result = 0 ;
42805 void *argp1 = 0 ;
42806 int res1 = 0 ;
42807 size_t val2 ;
42808 int ecode2 = 0 ;
42809 int val3 ;
42810 int ecode3 = 0 ;
42811 bool temp4 = false ;
42812 bool temp5 = false ;
42813 PyObject * obj0 = 0 ;
42814 PyObject * obj1 = 0 ;
42815 PyObject * obj2 = 0 ;
42816 PyObject * obj3 = 0 ;
42817 PyObject * obj4 = 0 ;
42818 char * kwnames[] = {
42819 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
42820 };
42821
42822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42824 if (!SWIG_IsOK(res1)) {
42825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42826 }
42827 arg1 = reinterpret_cast< wxMenu * >(argp1);
42828 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42829 if (!SWIG_IsOK(ecode2)) {
42830 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
42831 }
42832 arg2 = static_cast< size_t >(val2);
42833 ecode3 = SWIG_AsVal_int(obj2, &val3);
42834 if (!SWIG_IsOK(ecode3)) {
42835 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
42836 }
42837 arg3 = static_cast< int >(val3);
42838 {
42839 arg4 = wxString_in_helper(obj3);
42840 if (arg4 == NULL) SWIG_fail;
42841 temp4 = true;
42842 }
42843 if (obj4) {
42844 {
42845 arg5 = wxString_in_helper(obj4);
42846 if (arg5 == NULL) SWIG_fail;
42847 temp5 = true;
42848 }
42849 }
42850 {
42851 PyThreadState* __tstate = wxPyBeginAllowThreads();
42852 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
42853 wxPyEndAllowThreads(__tstate);
42854 if (PyErr_Occurred()) SWIG_fail;
42855 }
42856 {
42857 resultobj = wxPyMake_wxObject(result, (bool)0);
42858 }
42859 {
42860 if (temp4)
42861 delete arg4;
42862 }
42863 {
42864 if (temp5)
42865 delete arg5;
42866 }
42867 return resultobj;
42868 fail:
42869 {
42870 if (temp4)
42871 delete arg4;
42872 }
42873 {
42874 if (temp5)
42875 delete arg5;
42876 }
42877 return NULL;
42878 }
42879
42880
42881 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42882 PyObject *resultobj = 0;
42883 wxMenu *arg1 = (wxMenu *) 0 ;
42884 size_t arg2 ;
42885 int arg3 ;
42886 wxString *arg4 = 0 ;
42887 wxString const &arg5_defvalue = wxPyEmptyString ;
42888 wxString *arg5 = (wxString *) &arg5_defvalue ;
42889 wxMenuItem *result = 0 ;
42890 void *argp1 = 0 ;
42891 int res1 = 0 ;
42892 size_t val2 ;
42893 int ecode2 = 0 ;
42894 int val3 ;
42895 int ecode3 = 0 ;
42896 bool temp4 = false ;
42897 bool temp5 = false ;
42898 PyObject * obj0 = 0 ;
42899 PyObject * obj1 = 0 ;
42900 PyObject * obj2 = 0 ;
42901 PyObject * obj3 = 0 ;
42902 PyObject * obj4 = 0 ;
42903 char * kwnames[] = {
42904 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
42905 };
42906
42907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42909 if (!SWIG_IsOK(res1)) {
42910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42911 }
42912 arg1 = reinterpret_cast< wxMenu * >(argp1);
42913 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42914 if (!SWIG_IsOK(ecode2)) {
42915 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
42916 }
42917 arg2 = static_cast< size_t >(val2);
42918 ecode3 = SWIG_AsVal_int(obj2, &val3);
42919 if (!SWIG_IsOK(ecode3)) {
42920 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
42921 }
42922 arg3 = static_cast< int >(val3);
42923 {
42924 arg4 = wxString_in_helper(obj3);
42925 if (arg4 == NULL) SWIG_fail;
42926 temp4 = true;
42927 }
42928 if (obj4) {
42929 {
42930 arg5 = wxString_in_helper(obj4);
42931 if (arg5 == NULL) SWIG_fail;
42932 temp5 = true;
42933 }
42934 }
42935 {
42936 PyThreadState* __tstate = wxPyBeginAllowThreads();
42937 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
42938 wxPyEndAllowThreads(__tstate);
42939 if (PyErr_Occurred()) SWIG_fail;
42940 }
42941 {
42942 resultobj = wxPyMake_wxObject(result, (bool)0);
42943 }
42944 {
42945 if (temp4)
42946 delete arg4;
42947 }
42948 {
42949 if (temp5)
42950 delete arg5;
42951 }
42952 return resultobj;
42953 fail:
42954 {
42955 if (temp4)
42956 delete arg4;
42957 }
42958 {
42959 if (temp5)
42960 delete arg5;
42961 }
42962 return NULL;
42963 }
42964
42965
42966 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42967 PyObject *resultobj = 0;
42968 wxMenu *arg1 = (wxMenu *) 0 ;
42969 size_t arg2 ;
42970 int arg3 ;
42971 wxString *arg4 = 0 ;
42972 wxMenu *arg5 = (wxMenu *) 0 ;
42973 wxString const &arg6_defvalue = wxPyEmptyString ;
42974 wxString *arg6 = (wxString *) &arg6_defvalue ;
42975 wxMenuItem *result = 0 ;
42976 void *argp1 = 0 ;
42977 int res1 = 0 ;
42978 size_t val2 ;
42979 int ecode2 = 0 ;
42980 int val3 ;
42981 int ecode3 = 0 ;
42982 bool temp4 = false ;
42983 void *argp5 = 0 ;
42984 int res5 = 0 ;
42985 bool temp6 = false ;
42986 PyObject * obj0 = 0 ;
42987 PyObject * obj1 = 0 ;
42988 PyObject * obj2 = 0 ;
42989 PyObject * obj3 = 0 ;
42990 PyObject * obj4 = 0 ;
42991 PyObject * obj5 = 0 ;
42992 char * kwnames[] = {
42993 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
42994 };
42995
42996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42998 if (!SWIG_IsOK(res1)) {
42999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
43000 }
43001 arg1 = reinterpret_cast< wxMenu * >(argp1);
43002 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43003 if (!SWIG_IsOK(ecode2)) {
43004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
43005 }
43006 arg2 = static_cast< size_t >(val2);
43007 ecode3 = SWIG_AsVal_int(obj2, &val3);
43008 if (!SWIG_IsOK(ecode3)) {
43009 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
43010 }
43011 arg3 = static_cast< int >(val3);
43012 {
43013 arg4 = wxString_in_helper(obj3);
43014 if (arg4 == NULL) SWIG_fail;
43015 temp4 = true;
43016 }
43017 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
43018 if (!SWIG_IsOK(res5)) {
43019 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
43020 }
43021 arg5 = reinterpret_cast< wxMenu * >(argp5);
43022 if (obj5) {
43023 {
43024 arg6 = wxString_in_helper(obj5);
43025 if (arg6 == NULL) SWIG_fail;
43026 temp6 = true;
43027 }
43028 }
43029 {
43030 PyThreadState* __tstate = wxPyBeginAllowThreads();
43031 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
43032 wxPyEndAllowThreads(__tstate);
43033 if (PyErr_Occurred()) SWIG_fail;
43034 }
43035 {
43036 resultobj = wxPyMake_wxObject(result, (bool)0);
43037 }
43038 {
43039 if (temp4)
43040 delete arg4;
43041 }
43042 {
43043 if (temp6)
43044 delete arg6;
43045 }
43046 return resultobj;
43047 fail:
43048 {
43049 if (temp4)
43050 delete arg4;
43051 }
43052 {
43053 if (temp6)
43054 delete arg6;
43055 }
43056 return NULL;
43057 }
43058
43059
43060 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43061 PyObject *resultobj = 0;
43062 wxMenu *arg1 = (wxMenu *) 0 ;
43063 int arg2 ;
43064 wxString const &arg3_defvalue = wxPyEmptyString ;
43065 wxString *arg3 = (wxString *) &arg3_defvalue ;
43066 wxString const &arg4_defvalue = wxPyEmptyString ;
43067 wxString *arg4 = (wxString *) &arg4_defvalue ;
43068 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
43069 wxMenuItem *result = 0 ;
43070 void *argp1 = 0 ;
43071 int res1 = 0 ;
43072 int val2 ;
43073 int ecode2 = 0 ;
43074 bool temp3 = false ;
43075 bool temp4 = false ;
43076 int val5 ;
43077 int ecode5 = 0 ;
43078 PyObject * obj0 = 0 ;
43079 PyObject * obj1 = 0 ;
43080 PyObject * obj2 = 0 ;
43081 PyObject * obj3 = 0 ;
43082 PyObject * obj4 = 0 ;
43083 char * kwnames[] = {
43084 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
43085 };
43086
43087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
43088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43089 if (!SWIG_IsOK(res1)) {
43090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
43091 }
43092 arg1 = reinterpret_cast< wxMenu * >(argp1);
43093 ecode2 = SWIG_AsVal_int(obj1, &val2);
43094 if (!SWIG_IsOK(ecode2)) {
43095 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
43096 }
43097 arg2 = static_cast< int >(val2);
43098 if (obj2) {
43099 {
43100 arg3 = wxString_in_helper(obj2);
43101 if (arg3 == NULL) SWIG_fail;
43102 temp3 = true;
43103 }
43104 }
43105 if (obj3) {
43106 {
43107 arg4 = wxString_in_helper(obj3);
43108 if (arg4 == NULL) SWIG_fail;
43109 temp4 = true;
43110 }
43111 }
43112 if (obj4) {
43113 ecode5 = SWIG_AsVal_int(obj4, &val5);
43114 if (!SWIG_IsOK(ecode5)) {
43115 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
43116 }
43117 arg5 = static_cast< wxItemKind >(val5);
43118 }
43119 {
43120 PyThreadState* __tstate = wxPyBeginAllowThreads();
43121 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
43122 wxPyEndAllowThreads(__tstate);
43123 if (PyErr_Occurred()) SWIG_fail;
43124 }
43125 {
43126 resultobj = wxPyMake_wxObject(result, (bool)0);
43127 }
43128 {
43129 if (temp3)
43130 delete arg3;
43131 }
43132 {
43133 if (temp4)
43134 delete arg4;
43135 }
43136 return resultobj;
43137 fail:
43138 {
43139 if (temp3)
43140 delete arg3;
43141 }
43142 {
43143 if (temp4)
43144 delete arg4;
43145 }
43146 return NULL;
43147 }
43148
43149
43150 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43151 PyObject *resultobj = 0;
43152 wxMenu *arg1 = (wxMenu *) 0 ;
43153 wxMenuItem *result = 0 ;
43154 void *argp1 = 0 ;
43155 int res1 = 0 ;
43156 PyObject *swig_obj[1] ;
43157
43158 if (!args) SWIG_fail;
43159 swig_obj[0] = args;
43160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43161 if (!SWIG_IsOK(res1)) {
43162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
43163 }
43164 arg1 = reinterpret_cast< wxMenu * >(argp1);
43165 {
43166 PyThreadState* __tstate = wxPyBeginAllowThreads();
43167 result = (wxMenuItem *)(arg1)->PrependSeparator();
43168 wxPyEndAllowThreads(__tstate);
43169 if (PyErr_Occurred()) SWIG_fail;
43170 }
43171 {
43172 resultobj = wxPyMake_wxObject(result, (bool)0);
43173 }
43174 return resultobj;
43175 fail:
43176 return NULL;
43177 }
43178
43179
43180 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43181 PyObject *resultobj = 0;
43182 wxMenu *arg1 = (wxMenu *) 0 ;
43183 int arg2 ;
43184 wxString *arg3 = 0 ;
43185 wxString const &arg4_defvalue = wxPyEmptyString ;
43186 wxString *arg4 = (wxString *) &arg4_defvalue ;
43187 wxMenuItem *result = 0 ;
43188 void *argp1 = 0 ;
43189 int res1 = 0 ;
43190 int val2 ;
43191 int ecode2 = 0 ;
43192 bool temp3 = false ;
43193 bool temp4 = false ;
43194 PyObject * obj0 = 0 ;
43195 PyObject * obj1 = 0 ;
43196 PyObject * obj2 = 0 ;
43197 PyObject * obj3 = 0 ;
43198 char * kwnames[] = {
43199 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
43200 };
43201
43202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
43203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43204 if (!SWIG_IsOK(res1)) {
43205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43206 }
43207 arg1 = reinterpret_cast< wxMenu * >(argp1);
43208 ecode2 = SWIG_AsVal_int(obj1, &val2);
43209 if (!SWIG_IsOK(ecode2)) {
43210 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
43211 }
43212 arg2 = static_cast< int >(val2);
43213 {
43214 arg3 = wxString_in_helper(obj2);
43215 if (arg3 == NULL) SWIG_fail;
43216 temp3 = true;
43217 }
43218 if (obj3) {
43219 {
43220 arg4 = wxString_in_helper(obj3);
43221 if (arg4 == NULL) SWIG_fail;
43222 temp4 = true;
43223 }
43224 }
43225 {
43226 PyThreadState* __tstate = wxPyBeginAllowThreads();
43227 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
43228 wxPyEndAllowThreads(__tstate);
43229 if (PyErr_Occurred()) SWIG_fail;
43230 }
43231 {
43232 resultobj = wxPyMake_wxObject(result, (bool)0);
43233 }
43234 {
43235 if (temp3)
43236 delete arg3;
43237 }
43238 {
43239 if (temp4)
43240 delete arg4;
43241 }
43242 return resultobj;
43243 fail:
43244 {
43245 if (temp3)
43246 delete arg3;
43247 }
43248 {
43249 if (temp4)
43250 delete arg4;
43251 }
43252 return NULL;
43253 }
43254
43255
43256 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43257 PyObject *resultobj = 0;
43258 wxMenu *arg1 = (wxMenu *) 0 ;
43259 int arg2 ;
43260 wxString *arg3 = 0 ;
43261 wxString const &arg4_defvalue = wxPyEmptyString ;
43262 wxString *arg4 = (wxString *) &arg4_defvalue ;
43263 wxMenuItem *result = 0 ;
43264 void *argp1 = 0 ;
43265 int res1 = 0 ;
43266 int val2 ;
43267 int ecode2 = 0 ;
43268 bool temp3 = false ;
43269 bool temp4 = false ;
43270 PyObject * obj0 = 0 ;
43271 PyObject * obj1 = 0 ;
43272 PyObject * obj2 = 0 ;
43273 PyObject * obj3 = 0 ;
43274 char * kwnames[] = {
43275 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
43276 };
43277
43278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
43279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43280 if (!SWIG_IsOK(res1)) {
43281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43282 }
43283 arg1 = reinterpret_cast< wxMenu * >(argp1);
43284 ecode2 = SWIG_AsVal_int(obj1, &val2);
43285 if (!SWIG_IsOK(ecode2)) {
43286 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
43287 }
43288 arg2 = static_cast< int >(val2);
43289 {
43290 arg3 = wxString_in_helper(obj2);
43291 if (arg3 == NULL) SWIG_fail;
43292 temp3 = true;
43293 }
43294 if (obj3) {
43295 {
43296 arg4 = wxString_in_helper(obj3);
43297 if (arg4 == NULL) SWIG_fail;
43298 temp4 = true;
43299 }
43300 }
43301 {
43302 PyThreadState* __tstate = wxPyBeginAllowThreads();
43303 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
43304 wxPyEndAllowThreads(__tstate);
43305 if (PyErr_Occurred()) SWIG_fail;
43306 }
43307 {
43308 resultobj = wxPyMake_wxObject(result, (bool)0);
43309 }
43310 {
43311 if (temp3)
43312 delete arg3;
43313 }
43314 {
43315 if (temp4)
43316 delete arg4;
43317 }
43318 return resultobj;
43319 fail:
43320 {
43321 if (temp3)
43322 delete arg3;
43323 }
43324 {
43325 if (temp4)
43326 delete arg4;
43327 }
43328 return NULL;
43329 }
43330
43331
43332 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43333 PyObject *resultobj = 0;
43334 wxMenu *arg1 = (wxMenu *) 0 ;
43335 int arg2 ;
43336 wxString *arg3 = 0 ;
43337 wxMenu *arg4 = (wxMenu *) 0 ;
43338 wxString const &arg5_defvalue = wxPyEmptyString ;
43339 wxString *arg5 = (wxString *) &arg5_defvalue ;
43340 wxMenuItem *result = 0 ;
43341 void *argp1 = 0 ;
43342 int res1 = 0 ;
43343 int val2 ;
43344 int ecode2 = 0 ;
43345 bool temp3 = false ;
43346 void *argp4 = 0 ;
43347 int res4 = 0 ;
43348 bool temp5 = false ;
43349 PyObject * obj0 = 0 ;
43350 PyObject * obj1 = 0 ;
43351 PyObject * obj2 = 0 ;
43352 PyObject * obj3 = 0 ;
43353 PyObject * obj4 = 0 ;
43354 char * kwnames[] = {
43355 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
43356 };
43357
43358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
43359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43360 if (!SWIG_IsOK(res1)) {
43361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
43362 }
43363 arg1 = reinterpret_cast< wxMenu * >(argp1);
43364 ecode2 = SWIG_AsVal_int(obj1, &val2);
43365 if (!SWIG_IsOK(ecode2)) {
43366 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
43367 }
43368 arg2 = static_cast< int >(val2);
43369 {
43370 arg3 = wxString_in_helper(obj2);
43371 if (arg3 == NULL) SWIG_fail;
43372 temp3 = true;
43373 }
43374 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
43375 if (!SWIG_IsOK(res4)) {
43376 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
43377 }
43378 arg4 = reinterpret_cast< wxMenu * >(argp4);
43379 if (obj4) {
43380 {
43381 arg5 = wxString_in_helper(obj4);
43382 if (arg5 == NULL) SWIG_fail;
43383 temp5 = true;
43384 }
43385 }
43386 {
43387 PyThreadState* __tstate = wxPyBeginAllowThreads();
43388 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
43389 wxPyEndAllowThreads(__tstate);
43390 if (PyErr_Occurred()) SWIG_fail;
43391 }
43392 {
43393 resultobj = wxPyMake_wxObject(result, (bool)0);
43394 }
43395 {
43396 if (temp3)
43397 delete arg3;
43398 }
43399 {
43400 if (temp5)
43401 delete arg5;
43402 }
43403 return resultobj;
43404 fail:
43405 {
43406 if (temp3)
43407 delete arg3;
43408 }
43409 {
43410 if (temp5)
43411 delete arg5;
43412 }
43413 return NULL;
43414 }
43415
43416
43417 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43418 PyObject *resultobj = 0;
43419 wxMenu *arg1 = (wxMenu *) 0 ;
43420 int arg2 ;
43421 wxMenuItem *result = 0 ;
43422 void *argp1 = 0 ;
43423 int res1 = 0 ;
43424 int val2 ;
43425 int ecode2 = 0 ;
43426 PyObject * obj0 = 0 ;
43427 PyObject * obj1 = 0 ;
43428 char * kwnames[] = {
43429 (char *) "self",(char *) "id", NULL
43430 };
43431
43432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
43433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43434 if (!SWIG_IsOK(res1)) {
43435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
43436 }
43437 arg1 = reinterpret_cast< wxMenu * >(argp1);
43438 ecode2 = SWIG_AsVal_int(obj1, &val2);
43439 if (!SWIG_IsOK(ecode2)) {
43440 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
43441 }
43442 arg2 = static_cast< int >(val2);
43443 {
43444 PyThreadState* __tstate = wxPyBeginAllowThreads();
43445 result = (wxMenuItem *)(arg1)->Remove(arg2);
43446 wxPyEndAllowThreads(__tstate);
43447 if (PyErr_Occurred()) SWIG_fail;
43448 }
43449 {
43450 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
43451 }
43452 return resultobj;
43453 fail:
43454 return NULL;
43455 }
43456
43457
43458 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43459 PyObject *resultobj = 0;
43460 wxMenu *arg1 = (wxMenu *) 0 ;
43461 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43462 wxMenuItem *result = 0 ;
43463 void *argp1 = 0 ;
43464 int res1 = 0 ;
43465 void *argp2 = 0 ;
43466 int res2 = 0 ;
43467 PyObject * obj0 = 0 ;
43468 PyObject * obj1 = 0 ;
43469 char * kwnames[] = {
43470 (char *) "self",(char *) "item", NULL
43471 };
43472
43473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
43474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43475 if (!SWIG_IsOK(res1)) {
43476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43477 }
43478 arg1 = reinterpret_cast< wxMenu * >(argp1);
43479 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43480 if (!SWIG_IsOK(res2)) {
43481 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43482 }
43483 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43484 {
43485 PyThreadState* __tstate = wxPyBeginAllowThreads();
43486 result = (wxMenuItem *)(arg1)->Remove(arg2);
43487 wxPyEndAllowThreads(__tstate);
43488 if (PyErr_Occurred()) SWIG_fail;
43489 }
43490 {
43491 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
43492 }
43493 return resultobj;
43494 fail:
43495 return NULL;
43496 }
43497
43498
43499 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43500 PyObject *resultobj = 0;
43501 wxMenu *arg1 = (wxMenu *) 0 ;
43502 int arg2 ;
43503 bool result;
43504 void *argp1 = 0 ;
43505 int res1 = 0 ;
43506 int val2 ;
43507 int ecode2 = 0 ;
43508 PyObject * obj0 = 0 ;
43509 PyObject * obj1 = 0 ;
43510 char * kwnames[] = {
43511 (char *) "self",(char *) "id", NULL
43512 };
43513
43514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
43515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43516 if (!SWIG_IsOK(res1)) {
43517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
43518 }
43519 arg1 = reinterpret_cast< wxMenu * >(argp1);
43520 ecode2 = SWIG_AsVal_int(obj1, &val2);
43521 if (!SWIG_IsOK(ecode2)) {
43522 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
43523 }
43524 arg2 = static_cast< int >(val2);
43525 {
43526 PyThreadState* __tstate = wxPyBeginAllowThreads();
43527 result = (bool)(arg1)->Delete(arg2);
43528 wxPyEndAllowThreads(__tstate);
43529 if (PyErr_Occurred()) SWIG_fail;
43530 }
43531 {
43532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43533 }
43534 return resultobj;
43535 fail:
43536 return NULL;
43537 }
43538
43539
43540 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43541 PyObject *resultobj = 0;
43542 wxMenu *arg1 = (wxMenu *) 0 ;
43543 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43544 bool result;
43545 void *argp1 = 0 ;
43546 int res1 = 0 ;
43547 void *argp2 = 0 ;
43548 int res2 = 0 ;
43549 PyObject * obj0 = 0 ;
43550 PyObject * obj1 = 0 ;
43551 char * kwnames[] = {
43552 (char *) "self",(char *) "item", NULL
43553 };
43554
43555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
43556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43557 if (!SWIG_IsOK(res1)) {
43558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43559 }
43560 arg1 = reinterpret_cast< wxMenu * >(argp1);
43561 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43562 if (!SWIG_IsOK(res2)) {
43563 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43564 }
43565 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43566 {
43567 PyThreadState* __tstate = wxPyBeginAllowThreads();
43568 result = (bool)(arg1)->Delete(arg2);
43569 wxPyEndAllowThreads(__tstate);
43570 if (PyErr_Occurred()) SWIG_fail;
43571 }
43572 {
43573 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43574 }
43575 return resultobj;
43576 fail:
43577 return NULL;
43578 }
43579
43580
43581 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43582 PyObject *resultobj = 0;
43583 wxMenu *arg1 = (wxMenu *) 0 ;
43584 void *argp1 = 0 ;
43585 int res1 = 0 ;
43586 PyObject *swig_obj[1] ;
43587
43588 if (!args) SWIG_fail;
43589 swig_obj[0] = args;
43590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43591 if (!SWIG_IsOK(res1)) {
43592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
43593 }
43594 arg1 = reinterpret_cast< wxMenu * >(argp1);
43595 {
43596 PyThreadState* __tstate = wxPyBeginAllowThreads();
43597 wxMenu_Destroy(arg1);
43598 wxPyEndAllowThreads(__tstate);
43599 if (PyErr_Occurred()) SWIG_fail;
43600 }
43601 resultobj = SWIG_Py_Void();
43602 return resultobj;
43603 fail:
43604 return NULL;
43605 }
43606
43607
43608 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43609 PyObject *resultobj = 0;
43610 wxMenu *arg1 = (wxMenu *) 0 ;
43611 int arg2 ;
43612 bool result;
43613 void *argp1 = 0 ;
43614 int res1 = 0 ;
43615 int val2 ;
43616 int ecode2 = 0 ;
43617 PyObject * obj0 = 0 ;
43618 PyObject * obj1 = 0 ;
43619 char * kwnames[] = {
43620 (char *) "self",(char *) "id", NULL
43621 };
43622
43623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
43624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43625 if (!SWIG_IsOK(res1)) {
43626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
43627 }
43628 arg1 = reinterpret_cast< wxMenu * >(argp1);
43629 ecode2 = SWIG_AsVal_int(obj1, &val2);
43630 if (!SWIG_IsOK(ecode2)) {
43631 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
43632 }
43633 arg2 = static_cast< int >(val2);
43634 {
43635 PyThreadState* __tstate = wxPyBeginAllowThreads();
43636 result = (bool)(arg1)->Destroy(arg2);
43637 wxPyEndAllowThreads(__tstate);
43638 if (PyErr_Occurred()) SWIG_fail;
43639 }
43640 {
43641 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43642 }
43643 return resultobj;
43644 fail:
43645 return NULL;
43646 }
43647
43648
43649 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43650 PyObject *resultobj = 0;
43651 wxMenu *arg1 = (wxMenu *) 0 ;
43652 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43653 bool result;
43654 void *argp1 = 0 ;
43655 int res1 = 0 ;
43656 void *argp2 = 0 ;
43657 int res2 = 0 ;
43658 PyObject * obj0 = 0 ;
43659 PyObject * obj1 = 0 ;
43660 char * kwnames[] = {
43661 (char *) "self",(char *) "item", NULL
43662 };
43663
43664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
43665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43666 if (!SWIG_IsOK(res1)) {
43667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43668 }
43669 arg1 = reinterpret_cast< wxMenu * >(argp1);
43670 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43671 if (!SWIG_IsOK(res2)) {
43672 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43673 }
43674 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43675 {
43676 PyThreadState* __tstate = wxPyBeginAllowThreads();
43677 result = (bool)(arg1)->Destroy(arg2);
43678 wxPyEndAllowThreads(__tstate);
43679 if (PyErr_Occurred()) SWIG_fail;
43680 }
43681 {
43682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43683 }
43684 return resultobj;
43685 fail:
43686 return NULL;
43687 }
43688
43689
43690 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43691 PyObject *resultobj = 0;
43692 wxMenu *arg1 = (wxMenu *) 0 ;
43693 size_t result;
43694 void *argp1 = 0 ;
43695 int res1 = 0 ;
43696 PyObject *swig_obj[1] ;
43697
43698 if (!args) SWIG_fail;
43699 swig_obj[0] = args;
43700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43701 if (!SWIG_IsOK(res1)) {
43702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
43703 }
43704 arg1 = reinterpret_cast< wxMenu * >(argp1);
43705 {
43706 PyThreadState* __tstate = wxPyBeginAllowThreads();
43707 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
43708 wxPyEndAllowThreads(__tstate);
43709 if (PyErr_Occurred()) SWIG_fail;
43710 }
43711 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
43712 return resultobj;
43713 fail:
43714 return NULL;
43715 }
43716
43717
43718 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43719 PyObject *resultobj = 0;
43720 wxMenu *arg1 = (wxMenu *) 0 ;
43721 PyObject *result = 0 ;
43722 void *argp1 = 0 ;
43723 int res1 = 0 ;
43724 PyObject *swig_obj[1] ;
43725
43726 if (!args) SWIG_fail;
43727 swig_obj[0] = args;
43728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43729 if (!SWIG_IsOK(res1)) {
43730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
43731 }
43732 arg1 = reinterpret_cast< wxMenu * >(argp1);
43733 {
43734 PyThreadState* __tstate = wxPyBeginAllowThreads();
43735 result = (PyObject *)wxMenu_GetMenuItems(arg1);
43736 wxPyEndAllowThreads(__tstate);
43737 if (PyErr_Occurred()) SWIG_fail;
43738 }
43739 resultobj = result;
43740 return resultobj;
43741 fail:
43742 return NULL;
43743 }
43744
43745
43746 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43747 PyObject *resultobj = 0;
43748 wxMenu *arg1 = (wxMenu *) 0 ;
43749 wxString *arg2 = 0 ;
43750 int result;
43751 void *argp1 = 0 ;
43752 int res1 = 0 ;
43753 bool temp2 = false ;
43754 PyObject * obj0 = 0 ;
43755 PyObject * obj1 = 0 ;
43756 char * kwnames[] = {
43757 (char *) "self",(char *) "item", NULL
43758 };
43759
43760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
43761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43762 if (!SWIG_IsOK(res1)) {
43763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
43764 }
43765 arg1 = reinterpret_cast< wxMenu * >(argp1);
43766 {
43767 arg2 = wxString_in_helper(obj1);
43768 if (arg2 == NULL) SWIG_fail;
43769 temp2 = true;
43770 }
43771 {
43772 PyThreadState* __tstate = wxPyBeginAllowThreads();
43773 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
43774 wxPyEndAllowThreads(__tstate);
43775 if (PyErr_Occurred()) SWIG_fail;
43776 }
43777 resultobj = SWIG_From_int(static_cast< int >(result));
43778 {
43779 if (temp2)
43780 delete arg2;
43781 }
43782 return resultobj;
43783 fail:
43784 {
43785 if (temp2)
43786 delete arg2;
43787 }
43788 return NULL;
43789 }
43790
43791
43792 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43793 PyObject *resultobj = 0;
43794 wxMenu *arg1 = (wxMenu *) 0 ;
43795 int arg2 ;
43796 wxMenuItem *result = 0 ;
43797 void *argp1 = 0 ;
43798 int res1 = 0 ;
43799 int val2 ;
43800 int ecode2 = 0 ;
43801 PyObject * obj0 = 0 ;
43802 PyObject * obj1 = 0 ;
43803 char * kwnames[] = {
43804 (char *) "self",(char *) "id", NULL
43805 };
43806
43807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
43808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43809 if (!SWIG_IsOK(res1)) {
43810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
43811 }
43812 arg1 = reinterpret_cast< wxMenu * >(argp1);
43813 ecode2 = SWIG_AsVal_int(obj1, &val2);
43814 if (!SWIG_IsOK(ecode2)) {
43815 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
43816 }
43817 arg2 = static_cast< int >(val2);
43818 {
43819 PyThreadState* __tstate = wxPyBeginAllowThreads();
43820 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
43821 wxPyEndAllowThreads(__tstate);
43822 if (PyErr_Occurred()) SWIG_fail;
43823 }
43824 {
43825 resultobj = wxPyMake_wxObject(result, (bool)0);
43826 }
43827 return resultobj;
43828 fail:
43829 return NULL;
43830 }
43831
43832
43833 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43834 PyObject *resultobj = 0;
43835 wxMenu *arg1 = (wxMenu *) 0 ;
43836 size_t arg2 ;
43837 wxMenuItem *result = 0 ;
43838 void *argp1 = 0 ;
43839 int res1 = 0 ;
43840 size_t val2 ;
43841 int ecode2 = 0 ;
43842 PyObject * obj0 = 0 ;
43843 PyObject * obj1 = 0 ;
43844 char * kwnames[] = {
43845 (char *) "self",(char *) "position", NULL
43846 };
43847
43848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
43849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43850 if (!SWIG_IsOK(res1)) {
43851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
43852 }
43853 arg1 = reinterpret_cast< wxMenu * >(argp1);
43854 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43855 if (!SWIG_IsOK(ecode2)) {
43856 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
43857 }
43858 arg2 = static_cast< size_t >(val2);
43859 {
43860 PyThreadState* __tstate = wxPyBeginAllowThreads();
43861 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
43862 wxPyEndAllowThreads(__tstate);
43863 if (PyErr_Occurred()) SWIG_fail;
43864 }
43865 {
43866 resultobj = wxPyMake_wxObject(result, (bool)0);
43867 }
43868 return resultobj;
43869 fail:
43870 return NULL;
43871 }
43872
43873
43874 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43875 PyObject *resultobj = 0;
43876 wxMenu *arg1 = (wxMenu *) 0 ;
43877 int arg2 ;
43878 bool arg3 ;
43879 void *argp1 = 0 ;
43880 int res1 = 0 ;
43881 int val2 ;
43882 int ecode2 = 0 ;
43883 bool val3 ;
43884 int ecode3 = 0 ;
43885 PyObject * obj0 = 0 ;
43886 PyObject * obj1 = 0 ;
43887 PyObject * obj2 = 0 ;
43888 char * kwnames[] = {
43889 (char *) "self",(char *) "id",(char *) "enable", NULL
43890 };
43891
43892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43894 if (!SWIG_IsOK(res1)) {
43895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
43896 }
43897 arg1 = reinterpret_cast< wxMenu * >(argp1);
43898 ecode2 = SWIG_AsVal_int(obj1, &val2);
43899 if (!SWIG_IsOK(ecode2)) {
43900 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
43901 }
43902 arg2 = static_cast< int >(val2);
43903 ecode3 = SWIG_AsVal_bool(obj2, &val3);
43904 if (!SWIG_IsOK(ecode3)) {
43905 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
43906 }
43907 arg3 = static_cast< bool >(val3);
43908 {
43909 PyThreadState* __tstate = wxPyBeginAllowThreads();
43910 (arg1)->Enable(arg2,arg3);
43911 wxPyEndAllowThreads(__tstate);
43912 if (PyErr_Occurred()) SWIG_fail;
43913 }
43914 resultobj = SWIG_Py_Void();
43915 return resultobj;
43916 fail:
43917 return NULL;
43918 }
43919
43920
43921 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43922 PyObject *resultobj = 0;
43923 wxMenu *arg1 = (wxMenu *) 0 ;
43924 int arg2 ;
43925 bool result;
43926 void *argp1 = 0 ;
43927 int res1 = 0 ;
43928 int val2 ;
43929 int ecode2 = 0 ;
43930 PyObject * obj0 = 0 ;
43931 PyObject * obj1 = 0 ;
43932 char * kwnames[] = {
43933 (char *) "self",(char *) "id", NULL
43934 };
43935
43936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
43937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43938 if (!SWIG_IsOK(res1)) {
43939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
43940 }
43941 arg1 = reinterpret_cast< wxMenu * >(argp1);
43942 ecode2 = SWIG_AsVal_int(obj1, &val2);
43943 if (!SWIG_IsOK(ecode2)) {
43944 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
43945 }
43946 arg2 = static_cast< int >(val2);
43947 {
43948 PyThreadState* __tstate = wxPyBeginAllowThreads();
43949 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
43950 wxPyEndAllowThreads(__tstate);
43951 if (PyErr_Occurred()) SWIG_fail;
43952 }
43953 {
43954 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43955 }
43956 return resultobj;
43957 fail:
43958 return NULL;
43959 }
43960
43961
43962 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43963 PyObject *resultobj = 0;
43964 wxMenu *arg1 = (wxMenu *) 0 ;
43965 int arg2 ;
43966 bool arg3 ;
43967 void *argp1 = 0 ;
43968 int res1 = 0 ;
43969 int val2 ;
43970 int ecode2 = 0 ;
43971 bool val3 ;
43972 int ecode3 = 0 ;
43973 PyObject * obj0 = 0 ;
43974 PyObject * obj1 = 0 ;
43975 PyObject * obj2 = 0 ;
43976 char * kwnames[] = {
43977 (char *) "self",(char *) "id",(char *) "check", NULL
43978 };
43979
43980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43982 if (!SWIG_IsOK(res1)) {
43983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
43984 }
43985 arg1 = reinterpret_cast< wxMenu * >(argp1);
43986 ecode2 = SWIG_AsVal_int(obj1, &val2);
43987 if (!SWIG_IsOK(ecode2)) {
43988 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
43989 }
43990 arg2 = static_cast< int >(val2);
43991 ecode3 = SWIG_AsVal_bool(obj2, &val3);
43992 if (!SWIG_IsOK(ecode3)) {
43993 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
43994 }
43995 arg3 = static_cast< bool >(val3);
43996 {
43997 PyThreadState* __tstate = wxPyBeginAllowThreads();
43998 (arg1)->Check(arg2,arg3);
43999 wxPyEndAllowThreads(__tstate);
44000 if (PyErr_Occurred()) SWIG_fail;
44001 }
44002 resultobj = SWIG_Py_Void();
44003 return resultobj;
44004 fail:
44005 return NULL;
44006 }
44007
44008
44009 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44010 PyObject *resultobj = 0;
44011 wxMenu *arg1 = (wxMenu *) 0 ;
44012 int arg2 ;
44013 bool result;
44014 void *argp1 = 0 ;
44015 int res1 = 0 ;
44016 int val2 ;
44017 int ecode2 = 0 ;
44018 PyObject * obj0 = 0 ;
44019 PyObject * obj1 = 0 ;
44020 char * kwnames[] = {
44021 (char *) "self",(char *) "id", NULL
44022 };
44023
44024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
44025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44026 if (!SWIG_IsOK(res1)) {
44027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
44028 }
44029 arg1 = reinterpret_cast< wxMenu * >(argp1);
44030 ecode2 = SWIG_AsVal_int(obj1, &val2);
44031 if (!SWIG_IsOK(ecode2)) {
44032 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
44033 }
44034 arg2 = static_cast< int >(val2);
44035 {
44036 PyThreadState* __tstate = wxPyBeginAllowThreads();
44037 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
44038 wxPyEndAllowThreads(__tstate);
44039 if (PyErr_Occurred()) SWIG_fail;
44040 }
44041 {
44042 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44043 }
44044 return resultobj;
44045 fail:
44046 return NULL;
44047 }
44048
44049
44050 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44051 PyObject *resultobj = 0;
44052 wxMenu *arg1 = (wxMenu *) 0 ;
44053 int arg2 ;
44054 wxString *arg3 = 0 ;
44055 void *argp1 = 0 ;
44056 int res1 = 0 ;
44057 int val2 ;
44058 int ecode2 = 0 ;
44059 bool temp3 = false ;
44060 PyObject * obj0 = 0 ;
44061 PyObject * obj1 = 0 ;
44062 PyObject * obj2 = 0 ;
44063 char * kwnames[] = {
44064 (char *) "self",(char *) "id",(char *) "label", NULL
44065 };
44066
44067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44069 if (!SWIG_IsOK(res1)) {
44070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
44071 }
44072 arg1 = reinterpret_cast< wxMenu * >(argp1);
44073 ecode2 = SWIG_AsVal_int(obj1, &val2);
44074 if (!SWIG_IsOK(ecode2)) {
44075 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
44076 }
44077 arg2 = static_cast< int >(val2);
44078 {
44079 arg3 = wxString_in_helper(obj2);
44080 if (arg3 == NULL) SWIG_fail;
44081 temp3 = true;
44082 }
44083 {
44084 PyThreadState* __tstate = wxPyBeginAllowThreads();
44085 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
44086 wxPyEndAllowThreads(__tstate);
44087 if (PyErr_Occurred()) SWIG_fail;
44088 }
44089 resultobj = SWIG_Py_Void();
44090 {
44091 if (temp3)
44092 delete arg3;
44093 }
44094 return resultobj;
44095 fail:
44096 {
44097 if (temp3)
44098 delete arg3;
44099 }
44100 return NULL;
44101 }
44102
44103
44104 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44105 PyObject *resultobj = 0;
44106 wxMenu *arg1 = (wxMenu *) 0 ;
44107 int arg2 ;
44108 wxString result;
44109 void *argp1 = 0 ;
44110 int res1 = 0 ;
44111 int val2 ;
44112 int ecode2 = 0 ;
44113 PyObject * obj0 = 0 ;
44114 PyObject * obj1 = 0 ;
44115 char * kwnames[] = {
44116 (char *) "self",(char *) "id", NULL
44117 };
44118
44119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
44120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44121 if (!SWIG_IsOK(res1)) {
44122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
44123 }
44124 arg1 = reinterpret_cast< wxMenu * >(argp1);
44125 ecode2 = SWIG_AsVal_int(obj1, &val2);
44126 if (!SWIG_IsOK(ecode2)) {
44127 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
44128 }
44129 arg2 = static_cast< int >(val2);
44130 {
44131 PyThreadState* __tstate = wxPyBeginAllowThreads();
44132 result = ((wxMenu const *)arg1)->GetLabel(arg2);
44133 wxPyEndAllowThreads(__tstate);
44134 if (PyErr_Occurred()) SWIG_fail;
44135 }
44136 {
44137 #if wxUSE_UNICODE
44138 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44139 #else
44140 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44141 #endif
44142 }
44143 return resultobj;
44144 fail:
44145 return NULL;
44146 }
44147
44148
44149 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44150 PyObject *resultobj = 0;
44151 wxMenu *arg1 = (wxMenu *) 0 ;
44152 int arg2 ;
44153 wxString *arg3 = 0 ;
44154 void *argp1 = 0 ;
44155 int res1 = 0 ;
44156 int val2 ;
44157 int ecode2 = 0 ;
44158 bool temp3 = false ;
44159 PyObject * obj0 = 0 ;
44160 PyObject * obj1 = 0 ;
44161 PyObject * obj2 = 0 ;
44162 char * kwnames[] = {
44163 (char *) "self",(char *) "id",(char *) "helpString", NULL
44164 };
44165
44166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44168 if (!SWIG_IsOK(res1)) {
44169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
44170 }
44171 arg1 = reinterpret_cast< wxMenu * >(argp1);
44172 ecode2 = SWIG_AsVal_int(obj1, &val2);
44173 if (!SWIG_IsOK(ecode2)) {
44174 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
44175 }
44176 arg2 = static_cast< int >(val2);
44177 {
44178 arg3 = wxString_in_helper(obj2);
44179 if (arg3 == NULL) SWIG_fail;
44180 temp3 = true;
44181 }
44182 {
44183 PyThreadState* __tstate = wxPyBeginAllowThreads();
44184 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
44185 wxPyEndAllowThreads(__tstate);
44186 if (PyErr_Occurred()) SWIG_fail;
44187 }
44188 resultobj = SWIG_Py_Void();
44189 {
44190 if (temp3)
44191 delete arg3;
44192 }
44193 return resultobj;
44194 fail:
44195 {
44196 if (temp3)
44197 delete arg3;
44198 }
44199 return NULL;
44200 }
44201
44202
44203 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44204 PyObject *resultobj = 0;
44205 wxMenu *arg1 = (wxMenu *) 0 ;
44206 int arg2 ;
44207 wxString result;
44208 void *argp1 = 0 ;
44209 int res1 = 0 ;
44210 int val2 ;
44211 int ecode2 = 0 ;
44212 PyObject * obj0 = 0 ;
44213 PyObject * obj1 = 0 ;
44214 char * kwnames[] = {
44215 (char *) "self",(char *) "id", NULL
44216 };
44217
44218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
44219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44220 if (!SWIG_IsOK(res1)) {
44221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
44222 }
44223 arg1 = reinterpret_cast< wxMenu * >(argp1);
44224 ecode2 = SWIG_AsVal_int(obj1, &val2);
44225 if (!SWIG_IsOK(ecode2)) {
44226 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
44227 }
44228 arg2 = static_cast< int >(val2);
44229 {
44230 PyThreadState* __tstate = wxPyBeginAllowThreads();
44231 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
44232 wxPyEndAllowThreads(__tstate);
44233 if (PyErr_Occurred()) SWIG_fail;
44234 }
44235 {
44236 #if wxUSE_UNICODE
44237 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44238 #else
44239 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44240 #endif
44241 }
44242 return resultobj;
44243 fail:
44244 return NULL;
44245 }
44246
44247
44248 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44249 PyObject *resultobj = 0;
44250 wxMenu *arg1 = (wxMenu *) 0 ;
44251 wxString *arg2 = 0 ;
44252 void *argp1 = 0 ;
44253 int res1 = 0 ;
44254 bool temp2 = false ;
44255 PyObject * obj0 = 0 ;
44256 PyObject * obj1 = 0 ;
44257 char * kwnames[] = {
44258 (char *) "self",(char *) "title", NULL
44259 };
44260
44261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
44262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44263 if (!SWIG_IsOK(res1)) {
44264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
44265 }
44266 arg1 = reinterpret_cast< wxMenu * >(argp1);
44267 {
44268 arg2 = wxString_in_helper(obj1);
44269 if (arg2 == NULL) SWIG_fail;
44270 temp2 = true;
44271 }
44272 {
44273 PyThreadState* __tstate = wxPyBeginAllowThreads();
44274 (arg1)->SetTitle((wxString const &)*arg2);
44275 wxPyEndAllowThreads(__tstate);
44276 if (PyErr_Occurred()) SWIG_fail;
44277 }
44278 resultobj = SWIG_Py_Void();
44279 {
44280 if (temp2)
44281 delete arg2;
44282 }
44283 return resultobj;
44284 fail:
44285 {
44286 if (temp2)
44287 delete arg2;
44288 }
44289 return NULL;
44290 }
44291
44292
44293 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44294 PyObject *resultobj = 0;
44295 wxMenu *arg1 = (wxMenu *) 0 ;
44296 wxString result;
44297 void *argp1 = 0 ;
44298 int res1 = 0 ;
44299 PyObject *swig_obj[1] ;
44300
44301 if (!args) SWIG_fail;
44302 swig_obj[0] = args;
44303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44304 if (!SWIG_IsOK(res1)) {
44305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
44306 }
44307 arg1 = reinterpret_cast< wxMenu * >(argp1);
44308 {
44309 PyThreadState* __tstate = wxPyBeginAllowThreads();
44310 result = ((wxMenu const *)arg1)->GetTitle();
44311 wxPyEndAllowThreads(__tstate);
44312 if (PyErr_Occurred()) SWIG_fail;
44313 }
44314 {
44315 #if wxUSE_UNICODE
44316 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44317 #else
44318 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44319 #endif
44320 }
44321 return resultobj;
44322 fail:
44323 return NULL;
44324 }
44325
44326
44327 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44328 PyObject *resultobj = 0;
44329 wxMenu *arg1 = (wxMenu *) 0 ;
44330 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
44331 void *argp1 = 0 ;
44332 int res1 = 0 ;
44333 void *argp2 = 0 ;
44334 int res2 = 0 ;
44335 PyObject * obj0 = 0 ;
44336 PyObject * obj1 = 0 ;
44337 char * kwnames[] = {
44338 (char *) "self",(char *) "handler", NULL
44339 };
44340
44341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
44342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44343 if (!SWIG_IsOK(res1)) {
44344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
44345 }
44346 arg1 = reinterpret_cast< wxMenu * >(argp1);
44347 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
44348 if (!SWIG_IsOK(res2)) {
44349 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
44350 }
44351 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
44352 {
44353 PyThreadState* __tstate = wxPyBeginAllowThreads();
44354 (arg1)->SetEventHandler(arg2);
44355 wxPyEndAllowThreads(__tstate);
44356 if (PyErr_Occurred()) SWIG_fail;
44357 }
44358 resultobj = SWIG_Py_Void();
44359 return resultobj;
44360 fail:
44361 return NULL;
44362 }
44363
44364
44365 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44366 PyObject *resultobj = 0;
44367 wxMenu *arg1 = (wxMenu *) 0 ;
44368 wxEvtHandler *result = 0 ;
44369 void *argp1 = 0 ;
44370 int res1 = 0 ;
44371 PyObject *swig_obj[1] ;
44372
44373 if (!args) SWIG_fail;
44374 swig_obj[0] = args;
44375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44376 if (!SWIG_IsOK(res1)) {
44377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
44378 }
44379 arg1 = reinterpret_cast< wxMenu * >(argp1);
44380 {
44381 PyThreadState* __tstate = wxPyBeginAllowThreads();
44382 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
44383 wxPyEndAllowThreads(__tstate);
44384 if (PyErr_Occurred()) SWIG_fail;
44385 }
44386 {
44387 resultobj = wxPyMake_wxObject(result, 0);
44388 }
44389 return resultobj;
44390 fail:
44391 return NULL;
44392 }
44393
44394
44395 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44396 PyObject *resultobj = 0;
44397 wxMenu *arg1 = (wxMenu *) 0 ;
44398 wxWindow *arg2 = (wxWindow *) 0 ;
44399 void *argp1 = 0 ;
44400 int res1 = 0 ;
44401 void *argp2 = 0 ;
44402 int res2 = 0 ;
44403 PyObject * obj0 = 0 ;
44404 PyObject * obj1 = 0 ;
44405 char * kwnames[] = {
44406 (char *) "self",(char *) "win", NULL
44407 };
44408
44409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
44410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44411 if (!SWIG_IsOK(res1)) {
44412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
44413 }
44414 arg1 = reinterpret_cast< wxMenu * >(argp1);
44415 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
44416 if (!SWIG_IsOK(res2)) {
44417 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
44418 }
44419 arg2 = reinterpret_cast< wxWindow * >(argp2);
44420 {
44421 PyThreadState* __tstate = wxPyBeginAllowThreads();
44422 (arg1)->SetInvokingWindow(arg2);
44423 wxPyEndAllowThreads(__tstate);
44424 if (PyErr_Occurred()) SWIG_fail;
44425 }
44426 resultobj = SWIG_Py_Void();
44427 return resultobj;
44428 fail:
44429 return NULL;
44430 }
44431
44432
44433 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44434 PyObject *resultobj = 0;
44435 wxMenu *arg1 = (wxMenu *) 0 ;
44436 wxWindow *result = 0 ;
44437 void *argp1 = 0 ;
44438 int res1 = 0 ;
44439 PyObject *swig_obj[1] ;
44440
44441 if (!args) SWIG_fail;
44442 swig_obj[0] = args;
44443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44444 if (!SWIG_IsOK(res1)) {
44445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
44446 }
44447 arg1 = reinterpret_cast< wxMenu * >(argp1);
44448 {
44449 PyThreadState* __tstate = wxPyBeginAllowThreads();
44450 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
44451 wxPyEndAllowThreads(__tstate);
44452 if (PyErr_Occurred()) SWIG_fail;
44453 }
44454 {
44455 resultobj = wxPyMake_wxObject(result, 0);
44456 }
44457 return resultobj;
44458 fail:
44459 return NULL;
44460 }
44461
44462
44463 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44464 PyObject *resultobj = 0;
44465 wxMenu *arg1 = (wxMenu *) 0 ;
44466 long result;
44467 void *argp1 = 0 ;
44468 int res1 = 0 ;
44469 PyObject *swig_obj[1] ;
44470
44471 if (!args) SWIG_fail;
44472 swig_obj[0] = args;
44473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44474 if (!SWIG_IsOK(res1)) {
44475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
44476 }
44477 arg1 = reinterpret_cast< wxMenu * >(argp1);
44478 {
44479 PyThreadState* __tstate = wxPyBeginAllowThreads();
44480 result = (long)((wxMenu const *)arg1)->GetStyle();
44481 wxPyEndAllowThreads(__tstate);
44482 if (PyErr_Occurred()) SWIG_fail;
44483 }
44484 resultobj = SWIG_From_long(static_cast< long >(result));
44485 return resultobj;
44486 fail:
44487 return NULL;
44488 }
44489
44490
44491 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44492 PyObject *resultobj = 0;
44493 wxMenu *arg1 = (wxMenu *) 0 ;
44494 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
44495 void *argp1 = 0 ;
44496 int res1 = 0 ;
44497 void *argp2 = 0 ;
44498 int res2 = 0 ;
44499 PyObject * obj0 = 0 ;
44500 PyObject * obj1 = 0 ;
44501 char * kwnames[] = {
44502 (char *) "self",(char *) "source", NULL
44503 };
44504
44505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
44506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44507 if (!SWIG_IsOK(res1)) {
44508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
44509 }
44510 arg1 = reinterpret_cast< wxMenu * >(argp1);
44511 if (obj1) {
44512 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
44513 if (!SWIG_IsOK(res2)) {
44514 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
44515 }
44516 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
44517 }
44518 {
44519 PyThreadState* __tstate = wxPyBeginAllowThreads();
44520 (arg1)->UpdateUI(arg2);
44521 wxPyEndAllowThreads(__tstate);
44522 if (PyErr_Occurred()) SWIG_fail;
44523 }
44524 resultobj = SWIG_Py_Void();
44525 return resultobj;
44526 fail:
44527 return NULL;
44528 }
44529
44530
44531 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44532 PyObject *resultobj = 0;
44533 wxMenu *arg1 = (wxMenu *) 0 ;
44534 wxMenuBar *result = 0 ;
44535 void *argp1 = 0 ;
44536 int res1 = 0 ;
44537 PyObject *swig_obj[1] ;
44538
44539 if (!args) SWIG_fail;
44540 swig_obj[0] = args;
44541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44542 if (!SWIG_IsOK(res1)) {
44543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
44544 }
44545 arg1 = reinterpret_cast< wxMenu * >(argp1);
44546 {
44547 PyThreadState* __tstate = wxPyBeginAllowThreads();
44548 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
44549 wxPyEndAllowThreads(__tstate);
44550 if (PyErr_Occurred()) SWIG_fail;
44551 }
44552 {
44553 resultobj = wxPyMake_wxObject(result, (bool)0);
44554 }
44555 return resultobj;
44556 fail:
44557 return NULL;
44558 }
44559
44560
44561 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44562 PyObject *resultobj = 0;
44563 wxMenu *arg1 = (wxMenu *) 0 ;
44564 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
44565 void *argp1 = 0 ;
44566 int res1 = 0 ;
44567 void *argp2 = 0 ;
44568 int res2 = 0 ;
44569 PyObject * obj0 = 0 ;
44570 PyObject * obj1 = 0 ;
44571 char * kwnames[] = {
44572 (char *) "self",(char *) "menubar", NULL
44573 };
44574
44575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
44576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44577 if (!SWIG_IsOK(res1)) {
44578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
44579 }
44580 arg1 = reinterpret_cast< wxMenu * >(argp1);
44581 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
44582 if (!SWIG_IsOK(res2)) {
44583 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
44584 }
44585 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
44586 {
44587 PyThreadState* __tstate = wxPyBeginAllowThreads();
44588 (arg1)->Attach(arg2);
44589 wxPyEndAllowThreads(__tstate);
44590 if (PyErr_Occurred()) SWIG_fail;
44591 }
44592 resultobj = SWIG_Py_Void();
44593 return resultobj;
44594 fail:
44595 return NULL;
44596 }
44597
44598
44599 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44600 PyObject *resultobj = 0;
44601 wxMenu *arg1 = (wxMenu *) 0 ;
44602 void *argp1 = 0 ;
44603 int res1 = 0 ;
44604 PyObject *swig_obj[1] ;
44605
44606 if (!args) SWIG_fail;
44607 swig_obj[0] = args;
44608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44609 if (!SWIG_IsOK(res1)) {
44610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
44611 }
44612 arg1 = reinterpret_cast< wxMenu * >(argp1);
44613 {
44614 PyThreadState* __tstate = wxPyBeginAllowThreads();
44615 (arg1)->Detach();
44616 wxPyEndAllowThreads(__tstate);
44617 if (PyErr_Occurred()) SWIG_fail;
44618 }
44619 resultobj = SWIG_Py_Void();
44620 return resultobj;
44621 fail:
44622 return NULL;
44623 }
44624
44625
44626 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44627 PyObject *resultobj = 0;
44628 wxMenu *arg1 = (wxMenu *) 0 ;
44629 bool result;
44630 void *argp1 = 0 ;
44631 int res1 = 0 ;
44632 PyObject *swig_obj[1] ;
44633
44634 if (!args) SWIG_fail;
44635 swig_obj[0] = args;
44636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44637 if (!SWIG_IsOK(res1)) {
44638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
44639 }
44640 arg1 = reinterpret_cast< wxMenu * >(argp1);
44641 {
44642 PyThreadState* __tstate = wxPyBeginAllowThreads();
44643 result = (bool)((wxMenu const *)arg1)->IsAttached();
44644 wxPyEndAllowThreads(__tstate);
44645 if (PyErr_Occurred()) SWIG_fail;
44646 }
44647 {
44648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44649 }
44650 return resultobj;
44651 fail:
44652 return NULL;
44653 }
44654
44655
44656 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44657 PyObject *resultobj = 0;
44658 wxMenu *arg1 = (wxMenu *) 0 ;
44659 wxMenu *arg2 = (wxMenu *) 0 ;
44660 void *argp1 = 0 ;
44661 int res1 = 0 ;
44662 void *argp2 = 0 ;
44663 int res2 = 0 ;
44664 PyObject * obj0 = 0 ;
44665 PyObject * obj1 = 0 ;
44666 char * kwnames[] = {
44667 (char *) "self",(char *) "parent", NULL
44668 };
44669
44670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
44671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44672 if (!SWIG_IsOK(res1)) {
44673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
44674 }
44675 arg1 = reinterpret_cast< wxMenu * >(argp1);
44676 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44677 if (!SWIG_IsOK(res2)) {
44678 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
44679 }
44680 arg2 = reinterpret_cast< wxMenu * >(argp2);
44681 {
44682 PyThreadState* __tstate = wxPyBeginAllowThreads();
44683 (arg1)->SetParent(arg2);
44684 wxPyEndAllowThreads(__tstate);
44685 if (PyErr_Occurred()) SWIG_fail;
44686 }
44687 resultobj = SWIG_Py_Void();
44688 return resultobj;
44689 fail:
44690 return NULL;
44691 }
44692
44693
44694 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44695 PyObject *resultobj = 0;
44696 wxMenu *arg1 = (wxMenu *) 0 ;
44697 wxMenu *result = 0 ;
44698 void *argp1 = 0 ;
44699 int res1 = 0 ;
44700 PyObject *swig_obj[1] ;
44701
44702 if (!args) SWIG_fail;
44703 swig_obj[0] = args;
44704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44705 if (!SWIG_IsOK(res1)) {
44706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
44707 }
44708 arg1 = reinterpret_cast< wxMenu * >(argp1);
44709 {
44710 PyThreadState* __tstate = wxPyBeginAllowThreads();
44711 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
44712 wxPyEndAllowThreads(__tstate);
44713 if (PyErr_Occurred()) SWIG_fail;
44714 }
44715 {
44716 resultobj = wxPyMake_wxObject(result, 0);
44717 }
44718 return resultobj;
44719 fail:
44720 return NULL;
44721 }
44722
44723
44724 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44725 PyObject *obj;
44726 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44727 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
44728 return SWIG_Py_Void();
44729 }
44730
44731 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44732 return SWIG_Python_InitShadowInstance(args);
44733 }
44734
44735 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44736 PyObject *resultobj = 0;
44737 long arg1 = (long) 0 ;
44738 wxMenuBar *result = 0 ;
44739 long val1 ;
44740 int ecode1 = 0 ;
44741 PyObject * obj0 = 0 ;
44742 char * kwnames[] = {
44743 (char *) "style", NULL
44744 };
44745
44746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
44747 if (obj0) {
44748 ecode1 = SWIG_AsVal_long(obj0, &val1);
44749 if (!SWIG_IsOK(ecode1)) {
44750 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
44751 }
44752 arg1 = static_cast< long >(val1);
44753 }
44754 {
44755 if (!wxPyCheckForApp()) SWIG_fail;
44756 PyThreadState* __tstate = wxPyBeginAllowThreads();
44757 result = (wxMenuBar *)new wxMenuBar(arg1);
44758 wxPyEndAllowThreads(__tstate);
44759 if (PyErr_Occurred()) SWIG_fail;
44760 }
44761 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
44762 return resultobj;
44763 fail:
44764 return NULL;
44765 }
44766
44767
44768 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44769 PyObject *resultobj = 0;
44770 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44771 wxMenu *arg2 = (wxMenu *) 0 ;
44772 wxString *arg3 = 0 ;
44773 bool result;
44774 void *argp1 = 0 ;
44775 int res1 = 0 ;
44776 void *argp2 = 0 ;
44777 int res2 = 0 ;
44778 bool temp3 = false ;
44779 PyObject * obj0 = 0 ;
44780 PyObject * obj1 = 0 ;
44781 PyObject * obj2 = 0 ;
44782 char * kwnames[] = {
44783 (char *) "self",(char *) "menu",(char *) "title", NULL
44784 };
44785
44786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44788 if (!SWIG_IsOK(res1)) {
44789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44790 }
44791 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44792 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44793 if (!SWIG_IsOK(res2)) {
44794 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
44795 }
44796 arg2 = reinterpret_cast< wxMenu * >(argp2);
44797 {
44798 arg3 = wxString_in_helper(obj2);
44799 if (arg3 == NULL) SWIG_fail;
44800 temp3 = true;
44801 }
44802 {
44803 PyThreadState* __tstate = wxPyBeginAllowThreads();
44804 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
44805 wxPyEndAllowThreads(__tstate);
44806 if (PyErr_Occurred()) SWIG_fail;
44807 }
44808 {
44809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44810 }
44811 {
44812 if (temp3)
44813 delete arg3;
44814 }
44815 return resultobj;
44816 fail:
44817 {
44818 if (temp3)
44819 delete arg3;
44820 }
44821 return NULL;
44822 }
44823
44824
44825 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44826 PyObject *resultobj = 0;
44827 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44828 size_t arg2 ;
44829 wxMenu *arg3 = (wxMenu *) 0 ;
44830 wxString *arg4 = 0 ;
44831 bool result;
44832 void *argp1 = 0 ;
44833 int res1 = 0 ;
44834 size_t val2 ;
44835 int ecode2 = 0 ;
44836 void *argp3 = 0 ;
44837 int res3 = 0 ;
44838 bool temp4 = false ;
44839 PyObject * obj0 = 0 ;
44840 PyObject * obj1 = 0 ;
44841 PyObject * obj2 = 0 ;
44842 PyObject * obj3 = 0 ;
44843 char * kwnames[] = {
44844 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
44845 };
44846
44847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44849 if (!SWIG_IsOK(res1)) {
44850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44851 }
44852 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44853 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44854 if (!SWIG_IsOK(ecode2)) {
44855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
44856 }
44857 arg2 = static_cast< size_t >(val2);
44858 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
44859 if (!SWIG_IsOK(res3)) {
44860 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
44861 }
44862 arg3 = reinterpret_cast< wxMenu * >(argp3);
44863 {
44864 arg4 = wxString_in_helper(obj3);
44865 if (arg4 == NULL) SWIG_fail;
44866 temp4 = true;
44867 }
44868 {
44869 PyThreadState* __tstate = wxPyBeginAllowThreads();
44870 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
44871 wxPyEndAllowThreads(__tstate);
44872 if (PyErr_Occurred()) SWIG_fail;
44873 }
44874 {
44875 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44876 }
44877 {
44878 if (temp4)
44879 delete arg4;
44880 }
44881 return resultobj;
44882 fail:
44883 {
44884 if (temp4)
44885 delete arg4;
44886 }
44887 return NULL;
44888 }
44889
44890
44891 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44892 PyObject *resultobj = 0;
44893 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44894 size_t result;
44895 void *argp1 = 0 ;
44896 int res1 = 0 ;
44897 PyObject *swig_obj[1] ;
44898
44899 if (!args) SWIG_fail;
44900 swig_obj[0] = args;
44901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44902 if (!SWIG_IsOK(res1)) {
44903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44904 }
44905 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44906 {
44907 PyThreadState* __tstate = wxPyBeginAllowThreads();
44908 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
44909 wxPyEndAllowThreads(__tstate);
44910 if (PyErr_Occurred()) SWIG_fail;
44911 }
44912 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
44913 return resultobj;
44914 fail:
44915 return NULL;
44916 }
44917
44918
44919 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44920 PyObject *resultobj = 0;
44921 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44922 size_t arg2 ;
44923 wxMenu *result = 0 ;
44924 void *argp1 = 0 ;
44925 int res1 = 0 ;
44926 size_t val2 ;
44927 int ecode2 = 0 ;
44928 PyObject * obj0 = 0 ;
44929 PyObject * obj1 = 0 ;
44930 char * kwnames[] = {
44931 (char *) "self",(char *) "pos", NULL
44932 };
44933
44934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
44935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44936 if (!SWIG_IsOK(res1)) {
44937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44938 }
44939 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44940 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44941 if (!SWIG_IsOK(ecode2)) {
44942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
44943 }
44944 arg2 = static_cast< size_t >(val2);
44945 {
44946 PyThreadState* __tstate = wxPyBeginAllowThreads();
44947 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
44948 wxPyEndAllowThreads(__tstate);
44949 if (PyErr_Occurred()) SWIG_fail;
44950 }
44951 {
44952 resultobj = wxPyMake_wxObject(result, 0);
44953 }
44954 return resultobj;
44955 fail:
44956 return NULL;
44957 }
44958
44959
44960 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44961 PyObject *resultobj = 0;
44962 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44963 size_t arg2 ;
44964 wxMenu *arg3 = (wxMenu *) 0 ;
44965 wxString *arg4 = 0 ;
44966 wxMenu *result = 0 ;
44967 void *argp1 = 0 ;
44968 int res1 = 0 ;
44969 size_t val2 ;
44970 int ecode2 = 0 ;
44971 void *argp3 = 0 ;
44972 int res3 = 0 ;
44973 bool temp4 = false ;
44974 PyObject * obj0 = 0 ;
44975 PyObject * obj1 = 0 ;
44976 PyObject * obj2 = 0 ;
44977 PyObject * obj3 = 0 ;
44978 char * kwnames[] = {
44979 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
44980 };
44981
44982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44984 if (!SWIG_IsOK(res1)) {
44985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44986 }
44987 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44988 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44989 if (!SWIG_IsOK(ecode2)) {
44990 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
44991 }
44992 arg2 = static_cast< size_t >(val2);
44993 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
44994 if (!SWIG_IsOK(res3)) {
44995 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
44996 }
44997 arg3 = reinterpret_cast< wxMenu * >(argp3);
44998 {
44999 arg4 = wxString_in_helper(obj3);
45000 if (arg4 == NULL) SWIG_fail;
45001 temp4 = true;
45002 }
45003 {
45004 PyThreadState* __tstate = wxPyBeginAllowThreads();
45005 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
45006 wxPyEndAllowThreads(__tstate);
45007 if (PyErr_Occurred()) SWIG_fail;
45008 }
45009 {
45010 resultobj = wxPyMake_wxObject(result, 0);
45011 }
45012 {
45013 if (temp4)
45014 delete arg4;
45015 }
45016 return resultobj;
45017 fail:
45018 {
45019 if (temp4)
45020 delete arg4;
45021 }
45022 return NULL;
45023 }
45024
45025
45026 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45027 PyObject *resultobj = 0;
45028 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45029 size_t arg2 ;
45030 wxMenu *result = 0 ;
45031 void *argp1 = 0 ;
45032 int res1 = 0 ;
45033 size_t val2 ;
45034 int ecode2 = 0 ;
45035 PyObject * obj0 = 0 ;
45036 PyObject * obj1 = 0 ;
45037 char * kwnames[] = {
45038 (char *) "self",(char *) "pos", NULL
45039 };
45040
45041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
45042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45043 if (!SWIG_IsOK(res1)) {
45044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45045 }
45046 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45047 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45048 if (!SWIG_IsOK(ecode2)) {
45049 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
45050 }
45051 arg2 = static_cast< size_t >(val2);
45052 {
45053 PyThreadState* __tstate = wxPyBeginAllowThreads();
45054 result = (wxMenu *)(arg1)->Remove(arg2);
45055 wxPyEndAllowThreads(__tstate);
45056 if (PyErr_Occurred()) SWIG_fail;
45057 }
45058 {
45059 resultobj = wxPyMake_wxObject(result, 0);
45060 }
45061 return resultobj;
45062 fail:
45063 return NULL;
45064 }
45065
45066
45067 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45068 PyObject *resultobj = 0;
45069 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45070 size_t arg2 ;
45071 bool arg3 ;
45072 void *argp1 = 0 ;
45073 int res1 = 0 ;
45074 size_t val2 ;
45075 int ecode2 = 0 ;
45076 bool val3 ;
45077 int ecode3 = 0 ;
45078 PyObject * obj0 = 0 ;
45079 PyObject * obj1 = 0 ;
45080 PyObject * obj2 = 0 ;
45081 char * kwnames[] = {
45082 (char *) "self",(char *) "pos",(char *) "enable", NULL
45083 };
45084
45085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45087 if (!SWIG_IsOK(res1)) {
45088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45089 }
45090 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45091 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45092 if (!SWIG_IsOK(ecode2)) {
45093 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
45094 }
45095 arg2 = static_cast< size_t >(val2);
45096 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45097 if (!SWIG_IsOK(ecode3)) {
45098 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
45099 }
45100 arg3 = static_cast< bool >(val3);
45101 {
45102 PyThreadState* __tstate = wxPyBeginAllowThreads();
45103 (arg1)->EnableTop(arg2,arg3);
45104 wxPyEndAllowThreads(__tstate);
45105 if (PyErr_Occurred()) SWIG_fail;
45106 }
45107 resultobj = SWIG_Py_Void();
45108 return resultobj;
45109 fail:
45110 return NULL;
45111 }
45112
45113
45114 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45115 PyObject *resultobj = 0;
45116 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45117 size_t arg2 ;
45118 bool result;
45119 void *argp1 = 0 ;
45120 int res1 = 0 ;
45121 size_t val2 ;
45122 int ecode2 = 0 ;
45123 PyObject * obj0 = 0 ;
45124 PyObject * obj1 = 0 ;
45125 char * kwnames[] = {
45126 (char *) "self",(char *) "pos", NULL
45127 };
45128
45129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
45130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45131 if (!SWIG_IsOK(res1)) {
45132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45133 }
45134 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45135 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45136 if (!SWIG_IsOK(ecode2)) {
45137 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
45138 }
45139 arg2 = static_cast< size_t >(val2);
45140 {
45141 PyThreadState* __tstate = wxPyBeginAllowThreads();
45142 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
45143 wxPyEndAllowThreads(__tstate);
45144 if (PyErr_Occurred()) SWIG_fail;
45145 }
45146 {
45147 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45148 }
45149 return resultobj;
45150 fail:
45151 return NULL;
45152 }
45153
45154
45155 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45156 PyObject *resultobj = 0;
45157 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45158 size_t arg2 ;
45159 wxString *arg3 = 0 ;
45160 void *argp1 = 0 ;
45161 int res1 = 0 ;
45162 size_t val2 ;
45163 int ecode2 = 0 ;
45164 bool temp3 = false ;
45165 PyObject * obj0 = 0 ;
45166 PyObject * obj1 = 0 ;
45167 PyObject * obj2 = 0 ;
45168 char * kwnames[] = {
45169 (char *) "self",(char *) "pos",(char *) "label", NULL
45170 };
45171
45172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45174 if (!SWIG_IsOK(res1)) {
45175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45176 }
45177 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45178 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45179 if (!SWIG_IsOK(ecode2)) {
45180 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
45181 }
45182 arg2 = static_cast< size_t >(val2);
45183 {
45184 arg3 = wxString_in_helper(obj2);
45185 if (arg3 == NULL) SWIG_fail;
45186 temp3 = true;
45187 }
45188 {
45189 PyThreadState* __tstate = wxPyBeginAllowThreads();
45190 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
45191 wxPyEndAllowThreads(__tstate);
45192 if (PyErr_Occurred()) SWIG_fail;
45193 }
45194 resultobj = SWIG_Py_Void();
45195 {
45196 if (temp3)
45197 delete arg3;
45198 }
45199 return resultobj;
45200 fail:
45201 {
45202 if (temp3)
45203 delete arg3;
45204 }
45205 return NULL;
45206 }
45207
45208
45209 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45210 PyObject *resultobj = 0;
45211 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45212 size_t arg2 ;
45213 wxString result;
45214 void *argp1 = 0 ;
45215 int res1 = 0 ;
45216 size_t val2 ;
45217 int ecode2 = 0 ;
45218 PyObject * obj0 = 0 ;
45219 PyObject * obj1 = 0 ;
45220 char * kwnames[] = {
45221 (char *) "self",(char *) "pos", NULL
45222 };
45223
45224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
45225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45226 if (!SWIG_IsOK(res1)) {
45227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45228 }
45229 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45230 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45231 if (!SWIG_IsOK(ecode2)) {
45232 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
45233 }
45234 arg2 = static_cast< size_t >(val2);
45235 {
45236 PyThreadState* __tstate = wxPyBeginAllowThreads();
45237 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
45238 wxPyEndAllowThreads(__tstate);
45239 if (PyErr_Occurred()) SWIG_fail;
45240 }
45241 {
45242 #if wxUSE_UNICODE
45243 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45244 #else
45245 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45246 #endif
45247 }
45248 return resultobj;
45249 fail:
45250 return NULL;
45251 }
45252
45253
45254 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45255 PyObject *resultobj = 0;
45256 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45257 wxString *arg2 = 0 ;
45258 wxString *arg3 = 0 ;
45259 int result;
45260 void *argp1 = 0 ;
45261 int res1 = 0 ;
45262 bool temp2 = false ;
45263 bool temp3 = false ;
45264 PyObject * obj0 = 0 ;
45265 PyObject * obj1 = 0 ;
45266 PyObject * obj2 = 0 ;
45267 char * kwnames[] = {
45268 (char *) "self",(char *) "menu",(char *) "item", NULL
45269 };
45270
45271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45273 if (!SWIG_IsOK(res1)) {
45274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45275 }
45276 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45277 {
45278 arg2 = wxString_in_helper(obj1);
45279 if (arg2 == NULL) SWIG_fail;
45280 temp2 = true;
45281 }
45282 {
45283 arg3 = wxString_in_helper(obj2);
45284 if (arg3 == NULL) SWIG_fail;
45285 temp3 = true;
45286 }
45287 {
45288 PyThreadState* __tstate = wxPyBeginAllowThreads();
45289 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
45290 wxPyEndAllowThreads(__tstate);
45291 if (PyErr_Occurred()) SWIG_fail;
45292 }
45293 resultobj = SWIG_From_int(static_cast< int >(result));
45294 {
45295 if (temp2)
45296 delete arg2;
45297 }
45298 {
45299 if (temp3)
45300 delete arg3;
45301 }
45302 return resultobj;
45303 fail:
45304 {
45305 if (temp2)
45306 delete arg2;
45307 }
45308 {
45309 if (temp3)
45310 delete arg3;
45311 }
45312 return NULL;
45313 }
45314
45315
45316 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45317 PyObject *resultobj = 0;
45318 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45319 int arg2 ;
45320 wxMenuItem *result = 0 ;
45321 void *argp1 = 0 ;
45322 int res1 = 0 ;
45323 int val2 ;
45324 int ecode2 = 0 ;
45325 PyObject * obj0 = 0 ;
45326 PyObject * obj1 = 0 ;
45327 char * kwnames[] = {
45328 (char *) "self",(char *) "id", NULL
45329 };
45330
45331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
45332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45333 if (!SWIG_IsOK(res1)) {
45334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45335 }
45336 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45337 ecode2 = SWIG_AsVal_int(obj1, &val2);
45338 if (!SWIG_IsOK(ecode2)) {
45339 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
45340 }
45341 arg2 = static_cast< int >(val2);
45342 {
45343 PyThreadState* __tstate = wxPyBeginAllowThreads();
45344 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
45345 wxPyEndAllowThreads(__tstate);
45346 if (PyErr_Occurred()) SWIG_fail;
45347 }
45348 {
45349 resultobj = wxPyMake_wxObject(result, (bool)0);
45350 }
45351 return resultobj;
45352 fail:
45353 return NULL;
45354 }
45355
45356
45357 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45358 PyObject *resultobj = 0;
45359 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45360 wxString *arg2 = 0 ;
45361 int result;
45362 void *argp1 = 0 ;
45363 int res1 = 0 ;
45364 bool temp2 = false ;
45365 PyObject * obj0 = 0 ;
45366 PyObject * obj1 = 0 ;
45367 char * kwnames[] = {
45368 (char *) "self",(char *) "title", NULL
45369 };
45370
45371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
45372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45373 if (!SWIG_IsOK(res1)) {
45374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45375 }
45376 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45377 {
45378 arg2 = wxString_in_helper(obj1);
45379 if (arg2 == NULL) SWIG_fail;
45380 temp2 = true;
45381 }
45382 {
45383 PyThreadState* __tstate = wxPyBeginAllowThreads();
45384 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
45385 wxPyEndAllowThreads(__tstate);
45386 if (PyErr_Occurred()) SWIG_fail;
45387 }
45388 resultobj = SWIG_From_int(static_cast< int >(result));
45389 {
45390 if (temp2)
45391 delete arg2;
45392 }
45393 return resultobj;
45394 fail:
45395 {
45396 if (temp2)
45397 delete arg2;
45398 }
45399 return NULL;
45400 }
45401
45402
45403 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45404 PyObject *resultobj = 0;
45405 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45406 int arg2 ;
45407 bool arg3 ;
45408 void *argp1 = 0 ;
45409 int res1 = 0 ;
45410 int val2 ;
45411 int ecode2 = 0 ;
45412 bool val3 ;
45413 int ecode3 = 0 ;
45414 PyObject * obj0 = 0 ;
45415 PyObject * obj1 = 0 ;
45416 PyObject * obj2 = 0 ;
45417 char * kwnames[] = {
45418 (char *) "self",(char *) "id",(char *) "enable", NULL
45419 };
45420
45421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45422 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45423 if (!SWIG_IsOK(res1)) {
45424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45425 }
45426 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45427 ecode2 = SWIG_AsVal_int(obj1, &val2);
45428 if (!SWIG_IsOK(ecode2)) {
45429 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
45430 }
45431 arg2 = static_cast< int >(val2);
45432 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45433 if (!SWIG_IsOK(ecode3)) {
45434 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
45435 }
45436 arg3 = static_cast< bool >(val3);
45437 {
45438 PyThreadState* __tstate = wxPyBeginAllowThreads();
45439 (arg1)->Enable(arg2,arg3);
45440 wxPyEndAllowThreads(__tstate);
45441 if (PyErr_Occurred()) SWIG_fail;
45442 }
45443 resultobj = SWIG_Py_Void();
45444 return resultobj;
45445 fail:
45446 return NULL;
45447 }
45448
45449
45450 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45451 PyObject *resultobj = 0;
45452 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45453 int arg2 ;
45454 bool arg3 ;
45455 void *argp1 = 0 ;
45456 int res1 = 0 ;
45457 int val2 ;
45458 int ecode2 = 0 ;
45459 bool val3 ;
45460 int ecode3 = 0 ;
45461 PyObject * obj0 = 0 ;
45462 PyObject * obj1 = 0 ;
45463 PyObject * obj2 = 0 ;
45464 char * kwnames[] = {
45465 (char *) "self",(char *) "id",(char *) "check", NULL
45466 };
45467
45468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45470 if (!SWIG_IsOK(res1)) {
45471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45472 }
45473 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45474 ecode2 = SWIG_AsVal_int(obj1, &val2);
45475 if (!SWIG_IsOK(ecode2)) {
45476 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
45477 }
45478 arg2 = static_cast< int >(val2);
45479 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45480 if (!SWIG_IsOK(ecode3)) {
45481 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
45482 }
45483 arg3 = static_cast< bool >(val3);
45484 {
45485 PyThreadState* __tstate = wxPyBeginAllowThreads();
45486 (arg1)->Check(arg2,arg3);
45487 wxPyEndAllowThreads(__tstate);
45488 if (PyErr_Occurred()) SWIG_fail;
45489 }
45490 resultobj = SWIG_Py_Void();
45491 return resultobj;
45492 fail:
45493 return NULL;
45494 }
45495
45496
45497 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45498 PyObject *resultobj = 0;
45499 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45500 int arg2 ;
45501 bool result;
45502 void *argp1 = 0 ;
45503 int res1 = 0 ;
45504 int val2 ;
45505 int ecode2 = 0 ;
45506 PyObject * obj0 = 0 ;
45507 PyObject * obj1 = 0 ;
45508 char * kwnames[] = {
45509 (char *) "self",(char *) "id", NULL
45510 };
45511
45512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
45513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45514 if (!SWIG_IsOK(res1)) {
45515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45516 }
45517 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45518 ecode2 = SWIG_AsVal_int(obj1, &val2);
45519 if (!SWIG_IsOK(ecode2)) {
45520 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
45521 }
45522 arg2 = static_cast< int >(val2);
45523 {
45524 PyThreadState* __tstate = wxPyBeginAllowThreads();
45525 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
45526 wxPyEndAllowThreads(__tstate);
45527 if (PyErr_Occurred()) SWIG_fail;
45528 }
45529 {
45530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45531 }
45532 return resultobj;
45533 fail:
45534 return NULL;
45535 }
45536
45537
45538 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45539 PyObject *resultobj = 0;
45540 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45541 int arg2 ;
45542 bool result;
45543 void *argp1 = 0 ;
45544 int res1 = 0 ;
45545 int val2 ;
45546 int ecode2 = 0 ;
45547 PyObject * obj0 = 0 ;
45548 PyObject * obj1 = 0 ;
45549 char * kwnames[] = {
45550 (char *) "self",(char *) "id", NULL
45551 };
45552
45553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
45554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45555 if (!SWIG_IsOK(res1)) {
45556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45557 }
45558 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45559 ecode2 = SWIG_AsVal_int(obj1, &val2);
45560 if (!SWIG_IsOK(ecode2)) {
45561 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
45562 }
45563 arg2 = static_cast< int >(val2);
45564 {
45565 PyThreadState* __tstate = wxPyBeginAllowThreads();
45566 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
45567 wxPyEndAllowThreads(__tstate);
45568 if (PyErr_Occurred()) SWIG_fail;
45569 }
45570 {
45571 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45572 }
45573 return resultobj;
45574 fail:
45575 return NULL;
45576 }
45577
45578
45579 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45580 PyObject *resultobj = 0;
45581 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45582 int arg2 ;
45583 wxString *arg3 = 0 ;
45584 void *argp1 = 0 ;
45585 int res1 = 0 ;
45586 int val2 ;
45587 int ecode2 = 0 ;
45588 bool temp3 = false ;
45589 PyObject * obj0 = 0 ;
45590 PyObject * obj1 = 0 ;
45591 PyObject * obj2 = 0 ;
45592 char * kwnames[] = {
45593 (char *) "self",(char *) "id",(char *) "label", NULL
45594 };
45595
45596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45598 if (!SWIG_IsOK(res1)) {
45599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45600 }
45601 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45602 ecode2 = SWIG_AsVal_int(obj1, &val2);
45603 if (!SWIG_IsOK(ecode2)) {
45604 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
45605 }
45606 arg2 = static_cast< int >(val2);
45607 {
45608 arg3 = wxString_in_helper(obj2);
45609 if (arg3 == NULL) SWIG_fail;
45610 temp3 = true;
45611 }
45612 {
45613 PyThreadState* __tstate = wxPyBeginAllowThreads();
45614 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
45615 wxPyEndAllowThreads(__tstate);
45616 if (PyErr_Occurred()) SWIG_fail;
45617 }
45618 resultobj = SWIG_Py_Void();
45619 {
45620 if (temp3)
45621 delete arg3;
45622 }
45623 return resultobj;
45624 fail:
45625 {
45626 if (temp3)
45627 delete arg3;
45628 }
45629 return NULL;
45630 }
45631
45632
45633 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45634 PyObject *resultobj = 0;
45635 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45636 int arg2 ;
45637 wxString result;
45638 void *argp1 = 0 ;
45639 int res1 = 0 ;
45640 int val2 ;
45641 int ecode2 = 0 ;
45642 PyObject * obj0 = 0 ;
45643 PyObject * obj1 = 0 ;
45644 char * kwnames[] = {
45645 (char *) "self",(char *) "id", NULL
45646 };
45647
45648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
45649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45650 if (!SWIG_IsOK(res1)) {
45651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45652 }
45653 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45654 ecode2 = SWIG_AsVal_int(obj1, &val2);
45655 if (!SWIG_IsOK(ecode2)) {
45656 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
45657 }
45658 arg2 = static_cast< int >(val2);
45659 {
45660 PyThreadState* __tstate = wxPyBeginAllowThreads();
45661 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
45662 wxPyEndAllowThreads(__tstate);
45663 if (PyErr_Occurred()) SWIG_fail;
45664 }
45665 {
45666 #if wxUSE_UNICODE
45667 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45668 #else
45669 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45670 #endif
45671 }
45672 return resultobj;
45673 fail:
45674 return NULL;
45675 }
45676
45677
45678 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45679 PyObject *resultobj = 0;
45680 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45681 int arg2 ;
45682 wxString *arg3 = 0 ;
45683 void *argp1 = 0 ;
45684 int res1 = 0 ;
45685 int val2 ;
45686 int ecode2 = 0 ;
45687 bool temp3 = false ;
45688 PyObject * obj0 = 0 ;
45689 PyObject * obj1 = 0 ;
45690 PyObject * obj2 = 0 ;
45691 char * kwnames[] = {
45692 (char *) "self",(char *) "id",(char *) "helpString", NULL
45693 };
45694
45695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45697 if (!SWIG_IsOK(res1)) {
45698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45699 }
45700 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45701 ecode2 = SWIG_AsVal_int(obj1, &val2);
45702 if (!SWIG_IsOK(ecode2)) {
45703 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
45704 }
45705 arg2 = static_cast< int >(val2);
45706 {
45707 arg3 = wxString_in_helper(obj2);
45708 if (arg3 == NULL) SWIG_fail;
45709 temp3 = true;
45710 }
45711 {
45712 PyThreadState* __tstate = wxPyBeginAllowThreads();
45713 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
45714 wxPyEndAllowThreads(__tstate);
45715 if (PyErr_Occurred()) SWIG_fail;
45716 }
45717 resultobj = SWIG_Py_Void();
45718 {
45719 if (temp3)
45720 delete arg3;
45721 }
45722 return resultobj;
45723 fail:
45724 {
45725 if (temp3)
45726 delete arg3;
45727 }
45728 return NULL;
45729 }
45730
45731
45732 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45733 PyObject *resultobj = 0;
45734 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45735 int arg2 ;
45736 wxString result;
45737 void *argp1 = 0 ;
45738 int res1 = 0 ;
45739 int val2 ;
45740 int ecode2 = 0 ;
45741 PyObject * obj0 = 0 ;
45742 PyObject * obj1 = 0 ;
45743 char * kwnames[] = {
45744 (char *) "self",(char *) "id", NULL
45745 };
45746
45747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
45748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45749 if (!SWIG_IsOK(res1)) {
45750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45751 }
45752 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45753 ecode2 = SWIG_AsVal_int(obj1, &val2);
45754 if (!SWIG_IsOK(ecode2)) {
45755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
45756 }
45757 arg2 = static_cast< int >(val2);
45758 {
45759 PyThreadState* __tstate = wxPyBeginAllowThreads();
45760 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
45761 wxPyEndAllowThreads(__tstate);
45762 if (PyErr_Occurred()) SWIG_fail;
45763 }
45764 {
45765 #if wxUSE_UNICODE
45766 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45767 #else
45768 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45769 #endif
45770 }
45771 return resultobj;
45772 fail:
45773 return NULL;
45774 }
45775
45776
45777 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45778 PyObject *resultobj = 0;
45779 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45780 wxFrame *result = 0 ;
45781 void *argp1 = 0 ;
45782 int res1 = 0 ;
45783 PyObject *swig_obj[1] ;
45784
45785 if (!args) SWIG_fail;
45786 swig_obj[0] = args;
45787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45788 if (!SWIG_IsOK(res1)) {
45789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45790 }
45791 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45792 {
45793 PyThreadState* __tstate = wxPyBeginAllowThreads();
45794 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
45795 wxPyEndAllowThreads(__tstate);
45796 if (PyErr_Occurred()) SWIG_fail;
45797 }
45798 {
45799 resultobj = wxPyMake_wxObject(result, (bool)0);
45800 }
45801 return resultobj;
45802 fail:
45803 return NULL;
45804 }
45805
45806
45807 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45808 PyObject *resultobj = 0;
45809 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45810 bool result;
45811 void *argp1 = 0 ;
45812 int res1 = 0 ;
45813 PyObject *swig_obj[1] ;
45814
45815 if (!args) SWIG_fail;
45816 swig_obj[0] = args;
45817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45818 if (!SWIG_IsOK(res1)) {
45819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45820 }
45821 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45822 {
45823 PyThreadState* __tstate = wxPyBeginAllowThreads();
45824 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
45825 wxPyEndAllowThreads(__tstate);
45826 if (PyErr_Occurred()) SWIG_fail;
45827 }
45828 {
45829 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45830 }
45831 return resultobj;
45832 fail:
45833 return NULL;
45834 }
45835
45836
45837 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45838 PyObject *resultobj = 0;
45839 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45840 wxFrame *arg2 = (wxFrame *) 0 ;
45841 void *argp1 = 0 ;
45842 int res1 = 0 ;
45843 void *argp2 = 0 ;
45844 int res2 = 0 ;
45845 PyObject * obj0 = 0 ;
45846 PyObject * obj1 = 0 ;
45847 char * kwnames[] = {
45848 (char *) "self",(char *) "frame", NULL
45849 };
45850
45851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
45852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45853 if (!SWIG_IsOK(res1)) {
45854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45855 }
45856 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45857 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
45858 if (!SWIG_IsOK(res2)) {
45859 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
45860 }
45861 arg2 = reinterpret_cast< wxFrame * >(argp2);
45862 {
45863 PyThreadState* __tstate = wxPyBeginAllowThreads();
45864 (arg1)->Attach(arg2);
45865 wxPyEndAllowThreads(__tstate);
45866 if (PyErr_Occurred()) SWIG_fail;
45867 }
45868 resultobj = SWIG_Py_Void();
45869 return resultobj;
45870 fail:
45871 return NULL;
45872 }
45873
45874
45875 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45876 PyObject *resultobj = 0;
45877 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45878 void *argp1 = 0 ;
45879 int res1 = 0 ;
45880 PyObject *swig_obj[1] ;
45881
45882 if (!args) SWIG_fail;
45883 swig_obj[0] = args;
45884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45885 if (!SWIG_IsOK(res1)) {
45886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45887 }
45888 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45889 {
45890 PyThreadState* __tstate = wxPyBeginAllowThreads();
45891 (arg1)->Detach();
45892 wxPyEndAllowThreads(__tstate);
45893 if (PyErr_Occurred()) SWIG_fail;
45894 }
45895 resultobj = SWIG_Py_Void();
45896 return resultobj;
45897 fail:
45898 return NULL;
45899 }
45900
45901
45902 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45903 PyObject *resultobj = 0;
45904 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45905 void *argp1 = 0 ;
45906 int res1 = 0 ;
45907 PyObject *swig_obj[1] ;
45908
45909 if (!args) SWIG_fail;
45910 swig_obj[0] = args;
45911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45912 if (!SWIG_IsOK(res1)) {
45913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45914 }
45915 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45916 {
45917 PyThreadState* __tstate = wxPyBeginAllowThreads();
45918 (arg1)->UpdateMenus();
45919 wxPyEndAllowThreads(__tstate);
45920 if (PyErr_Occurred()) SWIG_fail;
45921 }
45922 resultobj = SWIG_Py_Void();
45923 return resultobj;
45924 fail:
45925 return NULL;
45926 }
45927
45928
45929 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45930 PyObject *resultobj = 0;
45931 bool arg1 ;
45932 bool val1 ;
45933 int ecode1 = 0 ;
45934 PyObject * obj0 = 0 ;
45935 char * kwnames[] = {
45936 (char *) "enable", NULL
45937 };
45938
45939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
45940 ecode1 = SWIG_AsVal_bool(obj0, &val1);
45941 if (!SWIG_IsOK(ecode1)) {
45942 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
45943 }
45944 arg1 = static_cast< bool >(val1);
45945 {
45946 PyThreadState* __tstate = wxPyBeginAllowThreads();
45947 wxMenuBar::SetAutoWindowMenu(arg1);
45948 wxPyEndAllowThreads(__tstate);
45949 if (PyErr_Occurred()) SWIG_fail;
45950 }
45951 resultobj = SWIG_Py_Void();
45952 return resultobj;
45953 fail:
45954 return NULL;
45955 }
45956
45957
45958 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45959 PyObject *resultobj = 0;
45960 bool result;
45961
45962 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
45963 {
45964 PyThreadState* __tstate = wxPyBeginAllowThreads();
45965 result = (bool)wxMenuBar::GetAutoWindowMenu();
45966 wxPyEndAllowThreads(__tstate);
45967 if (PyErr_Occurred()) SWIG_fail;
45968 }
45969 {
45970 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45971 }
45972 return resultobj;
45973 fail:
45974 return NULL;
45975 }
45976
45977
45978 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45979 PyObject *obj;
45980 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45981 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
45982 return SWIG_Py_Void();
45983 }
45984
45985 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45986 return SWIG_Python_InitShadowInstance(args);
45987 }
45988
45989 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45990 PyObject *resultobj = 0;
45991 wxMenu *arg1 = (wxMenu *) NULL ;
45992 int arg2 = (int) wxID_SEPARATOR ;
45993 wxString const &arg3_defvalue = wxPyEmptyString ;
45994 wxString *arg3 = (wxString *) &arg3_defvalue ;
45995 wxString const &arg4_defvalue = wxPyEmptyString ;
45996 wxString *arg4 = (wxString *) &arg4_defvalue ;
45997 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
45998 wxMenu *arg6 = (wxMenu *) NULL ;
45999 wxMenuItem *result = 0 ;
46000 void *argp1 = 0 ;
46001 int res1 = 0 ;
46002 int val2 ;
46003 int ecode2 = 0 ;
46004 bool temp3 = false ;
46005 bool temp4 = false ;
46006 int val5 ;
46007 int ecode5 = 0 ;
46008 void *argp6 = 0 ;
46009 int res6 = 0 ;
46010 PyObject * obj0 = 0 ;
46011 PyObject * obj1 = 0 ;
46012 PyObject * obj2 = 0 ;
46013 PyObject * obj3 = 0 ;
46014 PyObject * obj4 = 0 ;
46015 PyObject * obj5 = 0 ;
46016 char * kwnames[] = {
46017 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
46018 };
46019
46020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46021 if (obj0) {
46022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
46023 if (!SWIG_IsOK(res1)) {
46024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
46025 }
46026 arg1 = reinterpret_cast< wxMenu * >(argp1);
46027 }
46028 if (obj1) {
46029 ecode2 = SWIG_AsVal_int(obj1, &val2);
46030 if (!SWIG_IsOK(ecode2)) {
46031 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
46032 }
46033 arg2 = static_cast< int >(val2);
46034 }
46035 if (obj2) {
46036 {
46037 arg3 = wxString_in_helper(obj2);
46038 if (arg3 == NULL) SWIG_fail;
46039 temp3 = true;
46040 }
46041 }
46042 if (obj3) {
46043 {
46044 arg4 = wxString_in_helper(obj3);
46045 if (arg4 == NULL) SWIG_fail;
46046 temp4 = true;
46047 }
46048 }
46049 if (obj4) {
46050 ecode5 = SWIG_AsVal_int(obj4, &val5);
46051 if (!SWIG_IsOK(ecode5)) {
46052 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
46053 }
46054 arg5 = static_cast< wxItemKind >(val5);
46055 }
46056 if (obj5) {
46057 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
46058 if (!SWIG_IsOK(res6)) {
46059 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
46060 }
46061 arg6 = reinterpret_cast< wxMenu * >(argp6);
46062 }
46063 {
46064 PyThreadState* __tstate = wxPyBeginAllowThreads();
46065 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
46066 wxPyEndAllowThreads(__tstate);
46067 if (PyErr_Occurred()) SWIG_fail;
46068 }
46069 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_NEW | 0 );
46070 {
46071 if (temp3)
46072 delete arg3;
46073 }
46074 {
46075 if (temp4)
46076 delete arg4;
46077 }
46078 return resultobj;
46079 fail:
46080 {
46081 if (temp3)
46082 delete arg3;
46083 }
46084 {
46085 if (temp4)
46086 delete arg4;
46087 }
46088 return NULL;
46089 }
46090
46091
46092 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46093 PyObject *resultobj = 0;
46094 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46095 void *argp1 = 0 ;
46096 int res1 = 0 ;
46097 PyObject *swig_obj[1] ;
46098
46099 if (!args) SWIG_fail;
46100 swig_obj[0] = args;
46101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
46102 if (!SWIG_IsOK(res1)) {
46103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46104 }
46105 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46106 {
46107 PyThreadState* __tstate = wxPyBeginAllowThreads();
46108 delete arg1;
46109
46110 wxPyEndAllowThreads(__tstate);
46111 if (PyErr_Occurred()) SWIG_fail;
46112 }
46113 resultobj = SWIG_Py_Void();
46114 return resultobj;
46115 fail:
46116 return NULL;
46117 }
46118
46119
46120 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46121 PyObject *resultobj = 0;
46122 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46123 wxMenu *result = 0 ;
46124 void *argp1 = 0 ;
46125 int res1 = 0 ;
46126 PyObject *swig_obj[1] ;
46127
46128 if (!args) SWIG_fail;
46129 swig_obj[0] = args;
46130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46131 if (!SWIG_IsOK(res1)) {
46132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46133 }
46134 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46135 {
46136 PyThreadState* __tstate = wxPyBeginAllowThreads();
46137 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
46138 wxPyEndAllowThreads(__tstate);
46139 if (PyErr_Occurred()) SWIG_fail;
46140 }
46141 {
46142 resultobj = wxPyMake_wxObject(result, 0);
46143 }
46144 return resultobj;
46145 fail:
46146 return NULL;
46147 }
46148
46149
46150 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46151 PyObject *resultobj = 0;
46152 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46153 wxMenu *arg2 = (wxMenu *) 0 ;
46154 void *argp1 = 0 ;
46155 int res1 = 0 ;
46156 void *argp2 = 0 ;
46157 int res2 = 0 ;
46158 PyObject * obj0 = 0 ;
46159 PyObject * obj1 = 0 ;
46160 char * kwnames[] = {
46161 (char *) "self",(char *) "menu", NULL
46162 };
46163
46164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
46165 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46166 if (!SWIG_IsOK(res1)) {
46167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46168 }
46169 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46170 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
46171 if (!SWIG_IsOK(res2)) {
46172 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
46173 }
46174 arg2 = reinterpret_cast< wxMenu * >(argp2);
46175 {
46176 PyThreadState* __tstate = wxPyBeginAllowThreads();
46177 (arg1)->SetMenu(arg2);
46178 wxPyEndAllowThreads(__tstate);
46179 if (PyErr_Occurred()) SWIG_fail;
46180 }
46181 resultobj = SWIG_Py_Void();
46182 return resultobj;
46183 fail:
46184 return NULL;
46185 }
46186
46187
46188 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46189 PyObject *resultobj = 0;
46190 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46191 int arg2 ;
46192 void *argp1 = 0 ;
46193 int res1 = 0 ;
46194 int val2 ;
46195 int ecode2 = 0 ;
46196 PyObject * obj0 = 0 ;
46197 PyObject * obj1 = 0 ;
46198 char * kwnames[] = {
46199 (char *) "self",(char *) "id", NULL
46200 };
46201
46202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
46203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46204 if (!SWIG_IsOK(res1)) {
46205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46206 }
46207 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46208 ecode2 = SWIG_AsVal_int(obj1, &val2);
46209 if (!SWIG_IsOK(ecode2)) {
46210 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
46211 }
46212 arg2 = static_cast< int >(val2);
46213 {
46214 PyThreadState* __tstate = wxPyBeginAllowThreads();
46215 (arg1)->SetId(arg2);
46216 wxPyEndAllowThreads(__tstate);
46217 if (PyErr_Occurred()) SWIG_fail;
46218 }
46219 resultobj = SWIG_Py_Void();
46220 return resultobj;
46221 fail:
46222 return NULL;
46223 }
46224
46225
46226 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46227 PyObject *resultobj = 0;
46228 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46229 int result;
46230 void *argp1 = 0 ;
46231 int res1 = 0 ;
46232 PyObject *swig_obj[1] ;
46233
46234 if (!args) SWIG_fail;
46235 swig_obj[0] = args;
46236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46237 if (!SWIG_IsOK(res1)) {
46238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46239 }
46240 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46241 {
46242 PyThreadState* __tstate = wxPyBeginAllowThreads();
46243 result = (int)((wxMenuItem const *)arg1)->GetId();
46244 wxPyEndAllowThreads(__tstate);
46245 if (PyErr_Occurred()) SWIG_fail;
46246 }
46247 resultobj = SWIG_From_int(static_cast< int >(result));
46248 return resultobj;
46249 fail:
46250 return NULL;
46251 }
46252
46253
46254 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46255 PyObject *resultobj = 0;
46256 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46257 bool result;
46258 void *argp1 = 0 ;
46259 int res1 = 0 ;
46260 PyObject *swig_obj[1] ;
46261
46262 if (!args) SWIG_fail;
46263 swig_obj[0] = args;
46264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46265 if (!SWIG_IsOK(res1)) {
46266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46267 }
46268 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46269 {
46270 PyThreadState* __tstate = wxPyBeginAllowThreads();
46271 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
46272 wxPyEndAllowThreads(__tstate);
46273 if (PyErr_Occurred()) SWIG_fail;
46274 }
46275 {
46276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46277 }
46278 return resultobj;
46279 fail:
46280 return NULL;
46281 }
46282
46283
46284 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46285 PyObject *resultobj = 0;
46286 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46287 wxString *arg2 = 0 ;
46288 void *argp1 = 0 ;
46289 int res1 = 0 ;
46290 bool temp2 = false ;
46291 PyObject * obj0 = 0 ;
46292 PyObject * obj1 = 0 ;
46293 char * kwnames[] = {
46294 (char *) "self",(char *) "str", NULL
46295 };
46296
46297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
46298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46299 if (!SWIG_IsOK(res1)) {
46300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46301 }
46302 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46303 {
46304 arg2 = wxString_in_helper(obj1);
46305 if (arg2 == NULL) SWIG_fail;
46306 temp2 = true;
46307 }
46308 {
46309 PyThreadState* __tstate = wxPyBeginAllowThreads();
46310 (arg1)->SetText((wxString const &)*arg2);
46311 wxPyEndAllowThreads(__tstate);
46312 if (PyErr_Occurred()) SWIG_fail;
46313 }
46314 resultobj = SWIG_Py_Void();
46315 {
46316 if (temp2)
46317 delete arg2;
46318 }
46319 return resultobj;
46320 fail:
46321 {
46322 if (temp2)
46323 delete arg2;
46324 }
46325 return NULL;
46326 }
46327
46328
46329 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46330 PyObject *resultobj = 0;
46331 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46332 wxString result;
46333 void *argp1 = 0 ;
46334 int res1 = 0 ;
46335 PyObject *swig_obj[1] ;
46336
46337 if (!args) SWIG_fail;
46338 swig_obj[0] = args;
46339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46340 if (!SWIG_IsOK(res1)) {
46341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46342 }
46343 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46344 {
46345 PyThreadState* __tstate = wxPyBeginAllowThreads();
46346 result = ((wxMenuItem const *)arg1)->GetLabel();
46347 wxPyEndAllowThreads(__tstate);
46348 if (PyErr_Occurred()) SWIG_fail;
46349 }
46350 {
46351 #if wxUSE_UNICODE
46352 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46353 #else
46354 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46355 #endif
46356 }
46357 return resultobj;
46358 fail:
46359 return NULL;
46360 }
46361
46362
46363 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46364 PyObject *resultobj = 0;
46365 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46366 wxString *result = 0 ;
46367 void *argp1 = 0 ;
46368 int res1 = 0 ;
46369 PyObject *swig_obj[1] ;
46370
46371 if (!args) SWIG_fail;
46372 swig_obj[0] = args;
46373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46374 if (!SWIG_IsOK(res1)) {
46375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46376 }
46377 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46378 {
46379 PyThreadState* __tstate = wxPyBeginAllowThreads();
46380 {
46381 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
46382 result = (wxString *) &_result_ref;
46383 }
46384 wxPyEndAllowThreads(__tstate);
46385 if (PyErr_Occurred()) SWIG_fail;
46386 }
46387 {
46388 #if wxUSE_UNICODE
46389 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
46390 #else
46391 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
46392 #endif
46393 }
46394 return resultobj;
46395 fail:
46396 return NULL;
46397 }
46398
46399
46400 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46401 PyObject *resultobj = 0;
46402 wxString *arg1 = 0 ;
46403 wxString result;
46404 bool temp1 = false ;
46405 PyObject * obj0 = 0 ;
46406 char * kwnames[] = {
46407 (char *) "text", NULL
46408 };
46409
46410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
46411 {
46412 arg1 = wxString_in_helper(obj0);
46413 if (arg1 == NULL) SWIG_fail;
46414 temp1 = true;
46415 }
46416 {
46417 PyThreadState* __tstate = wxPyBeginAllowThreads();
46418 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
46419 wxPyEndAllowThreads(__tstate);
46420 if (PyErr_Occurred()) SWIG_fail;
46421 }
46422 {
46423 #if wxUSE_UNICODE
46424 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46425 #else
46426 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46427 #endif
46428 }
46429 {
46430 if (temp1)
46431 delete arg1;
46432 }
46433 return resultobj;
46434 fail:
46435 {
46436 if (temp1)
46437 delete arg1;
46438 }
46439 return NULL;
46440 }
46441
46442
46443 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46444 PyObject *resultobj = 0;
46445 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46446 wxItemKind result;
46447 void *argp1 = 0 ;
46448 int res1 = 0 ;
46449 PyObject *swig_obj[1] ;
46450
46451 if (!args) SWIG_fail;
46452 swig_obj[0] = args;
46453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46454 if (!SWIG_IsOK(res1)) {
46455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46456 }
46457 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46458 {
46459 PyThreadState* __tstate = wxPyBeginAllowThreads();
46460 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
46461 wxPyEndAllowThreads(__tstate);
46462 if (PyErr_Occurred()) SWIG_fail;
46463 }
46464 resultobj = SWIG_From_int(static_cast< int >(result));
46465 return resultobj;
46466 fail:
46467 return NULL;
46468 }
46469
46470
46471 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46472 PyObject *resultobj = 0;
46473 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46474 wxItemKind arg2 ;
46475 void *argp1 = 0 ;
46476 int res1 = 0 ;
46477 int val2 ;
46478 int ecode2 = 0 ;
46479 PyObject * obj0 = 0 ;
46480 PyObject * obj1 = 0 ;
46481 char * kwnames[] = {
46482 (char *) "self",(char *) "kind", NULL
46483 };
46484
46485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
46486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46487 if (!SWIG_IsOK(res1)) {
46488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46489 }
46490 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46491 ecode2 = SWIG_AsVal_int(obj1, &val2);
46492 if (!SWIG_IsOK(ecode2)) {
46493 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
46494 }
46495 arg2 = static_cast< wxItemKind >(val2);
46496 {
46497 PyThreadState* __tstate = wxPyBeginAllowThreads();
46498 (arg1)->SetKind(arg2);
46499 wxPyEndAllowThreads(__tstate);
46500 if (PyErr_Occurred()) SWIG_fail;
46501 }
46502 resultobj = SWIG_Py_Void();
46503 return resultobj;
46504 fail:
46505 return NULL;
46506 }
46507
46508
46509 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46510 PyObject *resultobj = 0;
46511 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46512 bool arg2 ;
46513 void *argp1 = 0 ;
46514 int res1 = 0 ;
46515 bool val2 ;
46516 int ecode2 = 0 ;
46517 PyObject * obj0 = 0 ;
46518 PyObject * obj1 = 0 ;
46519 char * kwnames[] = {
46520 (char *) "self",(char *) "checkable", NULL
46521 };
46522
46523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
46524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46525 if (!SWIG_IsOK(res1)) {
46526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46527 }
46528 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46529 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46530 if (!SWIG_IsOK(ecode2)) {
46531 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
46532 }
46533 arg2 = static_cast< bool >(val2);
46534 {
46535 PyThreadState* __tstate = wxPyBeginAllowThreads();
46536 (arg1)->SetCheckable(arg2);
46537 wxPyEndAllowThreads(__tstate);
46538 if (PyErr_Occurred()) SWIG_fail;
46539 }
46540 resultobj = SWIG_Py_Void();
46541 return resultobj;
46542 fail:
46543 return NULL;
46544 }
46545
46546
46547 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46548 PyObject *resultobj = 0;
46549 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46550 bool result;
46551 void *argp1 = 0 ;
46552 int res1 = 0 ;
46553 PyObject *swig_obj[1] ;
46554
46555 if (!args) SWIG_fail;
46556 swig_obj[0] = args;
46557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46558 if (!SWIG_IsOK(res1)) {
46559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46560 }
46561 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46562 {
46563 PyThreadState* __tstate = wxPyBeginAllowThreads();
46564 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
46565 wxPyEndAllowThreads(__tstate);
46566 if (PyErr_Occurred()) SWIG_fail;
46567 }
46568 {
46569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46570 }
46571 return resultobj;
46572 fail:
46573 return NULL;
46574 }
46575
46576
46577 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46578 PyObject *resultobj = 0;
46579 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46580 bool result;
46581 void *argp1 = 0 ;
46582 int res1 = 0 ;
46583 PyObject *swig_obj[1] ;
46584
46585 if (!args) SWIG_fail;
46586 swig_obj[0] = args;
46587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46588 if (!SWIG_IsOK(res1)) {
46589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46590 }
46591 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46592 {
46593 PyThreadState* __tstate = wxPyBeginAllowThreads();
46594 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
46595 wxPyEndAllowThreads(__tstate);
46596 if (PyErr_Occurred()) SWIG_fail;
46597 }
46598 {
46599 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46600 }
46601 return resultobj;
46602 fail:
46603 return NULL;
46604 }
46605
46606
46607 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46608 PyObject *resultobj = 0;
46609 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46610 wxMenu *arg2 = (wxMenu *) 0 ;
46611 void *argp1 = 0 ;
46612 int res1 = 0 ;
46613 void *argp2 = 0 ;
46614 int res2 = 0 ;
46615 PyObject * obj0 = 0 ;
46616 PyObject * obj1 = 0 ;
46617 char * kwnames[] = {
46618 (char *) "self",(char *) "menu", NULL
46619 };
46620
46621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
46622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46623 if (!SWIG_IsOK(res1)) {
46624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46625 }
46626 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46627 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
46628 if (!SWIG_IsOK(res2)) {
46629 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
46630 }
46631 arg2 = reinterpret_cast< wxMenu * >(argp2);
46632 {
46633 PyThreadState* __tstate = wxPyBeginAllowThreads();
46634 (arg1)->SetSubMenu(arg2);
46635 wxPyEndAllowThreads(__tstate);
46636 if (PyErr_Occurred()) SWIG_fail;
46637 }
46638 resultobj = SWIG_Py_Void();
46639 return resultobj;
46640 fail:
46641 return NULL;
46642 }
46643
46644
46645 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46646 PyObject *resultobj = 0;
46647 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46648 wxMenu *result = 0 ;
46649 void *argp1 = 0 ;
46650 int res1 = 0 ;
46651 PyObject *swig_obj[1] ;
46652
46653 if (!args) SWIG_fail;
46654 swig_obj[0] = args;
46655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46656 if (!SWIG_IsOK(res1)) {
46657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46658 }
46659 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46660 {
46661 PyThreadState* __tstate = wxPyBeginAllowThreads();
46662 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
46663 wxPyEndAllowThreads(__tstate);
46664 if (PyErr_Occurred()) SWIG_fail;
46665 }
46666 {
46667 resultobj = wxPyMake_wxObject(result, 0);
46668 }
46669 return resultobj;
46670 fail:
46671 return NULL;
46672 }
46673
46674
46675 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46676 PyObject *resultobj = 0;
46677 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46678 bool arg2 = (bool) true ;
46679 void *argp1 = 0 ;
46680 int res1 = 0 ;
46681 bool val2 ;
46682 int ecode2 = 0 ;
46683 PyObject * obj0 = 0 ;
46684 PyObject * obj1 = 0 ;
46685 char * kwnames[] = {
46686 (char *) "self",(char *) "enable", NULL
46687 };
46688
46689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
46690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46691 if (!SWIG_IsOK(res1)) {
46692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46693 }
46694 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46695 if (obj1) {
46696 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46697 if (!SWIG_IsOK(ecode2)) {
46698 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
46699 }
46700 arg2 = static_cast< bool >(val2);
46701 }
46702 {
46703 PyThreadState* __tstate = wxPyBeginAllowThreads();
46704 (arg1)->Enable(arg2);
46705 wxPyEndAllowThreads(__tstate);
46706 if (PyErr_Occurred()) SWIG_fail;
46707 }
46708 resultobj = SWIG_Py_Void();
46709 return resultobj;
46710 fail:
46711 return NULL;
46712 }
46713
46714
46715 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46716 PyObject *resultobj = 0;
46717 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46718 bool result;
46719 void *argp1 = 0 ;
46720 int res1 = 0 ;
46721 PyObject *swig_obj[1] ;
46722
46723 if (!args) SWIG_fail;
46724 swig_obj[0] = args;
46725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46726 if (!SWIG_IsOK(res1)) {
46727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46728 }
46729 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46730 {
46731 PyThreadState* __tstate = wxPyBeginAllowThreads();
46732 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
46733 wxPyEndAllowThreads(__tstate);
46734 if (PyErr_Occurred()) SWIG_fail;
46735 }
46736 {
46737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46738 }
46739 return resultobj;
46740 fail:
46741 return NULL;
46742 }
46743
46744
46745 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46746 PyObject *resultobj = 0;
46747 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46748 bool arg2 = (bool) true ;
46749 void *argp1 = 0 ;
46750 int res1 = 0 ;
46751 bool val2 ;
46752 int ecode2 = 0 ;
46753 PyObject * obj0 = 0 ;
46754 PyObject * obj1 = 0 ;
46755 char * kwnames[] = {
46756 (char *) "self",(char *) "check", NULL
46757 };
46758
46759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
46760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46761 if (!SWIG_IsOK(res1)) {
46762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46763 }
46764 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46765 if (obj1) {
46766 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46767 if (!SWIG_IsOK(ecode2)) {
46768 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
46769 }
46770 arg2 = static_cast< bool >(val2);
46771 }
46772 {
46773 PyThreadState* __tstate = wxPyBeginAllowThreads();
46774 (arg1)->Check(arg2);
46775 wxPyEndAllowThreads(__tstate);
46776 if (PyErr_Occurred()) SWIG_fail;
46777 }
46778 resultobj = SWIG_Py_Void();
46779 return resultobj;
46780 fail:
46781 return NULL;
46782 }
46783
46784
46785 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46786 PyObject *resultobj = 0;
46787 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46788 bool result;
46789 void *argp1 = 0 ;
46790 int res1 = 0 ;
46791 PyObject *swig_obj[1] ;
46792
46793 if (!args) SWIG_fail;
46794 swig_obj[0] = args;
46795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46796 if (!SWIG_IsOK(res1)) {
46797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46798 }
46799 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46800 {
46801 PyThreadState* __tstate = wxPyBeginAllowThreads();
46802 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
46803 wxPyEndAllowThreads(__tstate);
46804 if (PyErr_Occurred()) SWIG_fail;
46805 }
46806 {
46807 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46808 }
46809 return resultobj;
46810 fail:
46811 return NULL;
46812 }
46813
46814
46815 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46816 PyObject *resultobj = 0;
46817 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46818 void *argp1 = 0 ;
46819 int res1 = 0 ;
46820 PyObject *swig_obj[1] ;
46821
46822 if (!args) SWIG_fail;
46823 swig_obj[0] = args;
46824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46825 if (!SWIG_IsOK(res1)) {
46826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46827 }
46828 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46829 {
46830 PyThreadState* __tstate = wxPyBeginAllowThreads();
46831 (arg1)->Toggle();
46832 wxPyEndAllowThreads(__tstate);
46833 if (PyErr_Occurred()) SWIG_fail;
46834 }
46835 resultobj = SWIG_Py_Void();
46836 return resultobj;
46837 fail:
46838 return NULL;
46839 }
46840
46841
46842 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46843 PyObject *resultobj = 0;
46844 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46845 wxString *arg2 = 0 ;
46846 void *argp1 = 0 ;
46847 int res1 = 0 ;
46848 bool temp2 = false ;
46849 PyObject * obj0 = 0 ;
46850 PyObject * obj1 = 0 ;
46851 char * kwnames[] = {
46852 (char *) "self",(char *) "str", NULL
46853 };
46854
46855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
46856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46857 if (!SWIG_IsOK(res1)) {
46858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46859 }
46860 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46861 {
46862 arg2 = wxString_in_helper(obj1);
46863 if (arg2 == NULL) SWIG_fail;
46864 temp2 = true;
46865 }
46866 {
46867 PyThreadState* __tstate = wxPyBeginAllowThreads();
46868 (arg1)->SetHelp((wxString const &)*arg2);
46869 wxPyEndAllowThreads(__tstate);
46870 if (PyErr_Occurred()) SWIG_fail;
46871 }
46872 resultobj = SWIG_Py_Void();
46873 {
46874 if (temp2)
46875 delete arg2;
46876 }
46877 return resultobj;
46878 fail:
46879 {
46880 if (temp2)
46881 delete arg2;
46882 }
46883 return NULL;
46884 }
46885
46886
46887 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46888 PyObject *resultobj = 0;
46889 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46890 wxString *result = 0 ;
46891 void *argp1 = 0 ;
46892 int res1 = 0 ;
46893 PyObject *swig_obj[1] ;
46894
46895 if (!args) SWIG_fail;
46896 swig_obj[0] = args;
46897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46898 if (!SWIG_IsOK(res1)) {
46899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46900 }
46901 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46902 {
46903 PyThreadState* __tstate = wxPyBeginAllowThreads();
46904 {
46905 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
46906 result = (wxString *) &_result_ref;
46907 }
46908 wxPyEndAllowThreads(__tstate);
46909 if (PyErr_Occurred()) SWIG_fail;
46910 }
46911 {
46912 #if wxUSE_UNICODE
46913 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
46914 #else
46915 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
46916 #endif
46917 }
46918 return resultobj;
46919 fail:
46920 return NULL;
46921 }
46922
46923
46924 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46925 PyObject *resultobj = 0;
46926 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46927 wxAcceleratorEntry *result = 0 ;
46928 void *argp1 = 0 ;
46929 int res1 = 0 ;
46930 PyObject *swig_obj[1] ;
46931
46932 if (!args) SWIG_fail;
46933 swig_obj[0] = args;
46934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46935 if (!SWIG_IsOK(res1)) {
46936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46937 }
46938 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46939 {
46940 PyThreadState* __tstate = wxPyBeginAllowThreads();
46941 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
46942 wxPyEndAllowThreads(__tstate);
46943 if (PyErr_Occurred()) SWIG_fail;
46944 }
46945 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
46946 return resultobj;
46947 fail:
46948 return NULL;
46949 }
46950
46951
46952 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46953 PyObject *resultobj = 0;
46954 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46955 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
46956 void *argp1 = 0 ;
46957 int res1 = 0 ;
46958 void *argp2 = 0 ;
46959 int res2 = 0 ;
46960 PyObject * obj0 = 0 ;
46961 PyObject * obj1 = 0 ;
46962 char * kwnames[] = {
46963 (char *) "self",(char *) "accel", NULL
46964 };
46965
46966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
46967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46968 if (!SWIG_IsOK(res1)) {
46969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46970 }
46971 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46972 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
46973 if (!SWIG_IsOK(res2)) {
46974 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
46975 }
46976 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
46977 {
46978 PyThreadState* __tstate = wxPyBeginAllowThreads();
46979 (arg1)->SetAccel(arg2);
46980 wxPyEndAllowThreads(__tstate);
46981 if (PyErr_Occurred()) SWIG_fail;
46982 }
46983 resultobj = SWIG_Py_Void();
46984 return resultobj;
46985 fail:
46986 return NULL;
46987 }
46988
46989
46990 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46991 PyObject *resultobj = 0;
46992 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46993 wxBitmap *arg2 = 0 ;
46994 void *argp1 = 0 ;
46995 int res1 = 0 ;
46996 void *argp2 = 0 ;
46997 int res2 = 0 ;
46998 PyObject * obj0 = 0 ;
46999 PyObject * obj1 = 0 ;
47000 char * kwnames[] = {
47001 (char *) "self",(char *) "bitmap", NULL
47002 };
47003
47004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
47005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47006 if (!SWIG_IsOK(res1)) {
47007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47008 }
47009 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47010 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
47011 if (!SWIG_IsOK(res2)) {
47012 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47013 }
47014 if (!argp2) {
47015 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47016 }
47017 arg2 = reinterpret_cast< wxBitmap * >(argp2);
47018 {
47019 PyThreadState* __tstate = wxPyBeginAllowThreads();
47020 (arg1)->SetBitmap((wxBitmap const &)*arg2);
47021 wxPyEndAllowThreads(__tstate);
47022 if (PyErr_Occurred()) SWIG_fail;
47023 }
47024 resultobj = SWIG_Py_Void();
47025 return resultobj;
47026 fail:
47027 return NULL;
47028 }
47029
47030
47031 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47032 PyObject *resultobj = 0;
47033 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47034 wxBitmap *result = 0 ;
47035 void *argp1 = 0 ;
47036 int res1 = 0 ;
47037 PyObject *swig_obj[1] ;
47038
47039 if (!args) SWIG_fail;
47040 swig_obj[0] = args;
47041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47042 if (!SWIG_IsOK(res1)) {
47043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47044 }
47045 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47046 {
47047 PyThreadState* __tstate = wxPyBeginAllowThreads();
47048 {
47049 wxBitmap const &_result_ref = (arg1)->GetBitmap();
47050 result = (wxBitmap *) &_result_ref;
47051 }
47052 wxPyEndAllowThreads(__tstate);
47053 if (PyErr_Occurred()) SWIG_fail;
47054 }
47055 {
47056 wxBitmap* resultptr = new wxBitmap(*result);
47057 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
47058 }
47059 return resultobj;
47060 fail:
47061 return NULL;
47062 }
47063
47064
47065 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47066 PyObject *resultobj = 0;
47067 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47068 wxFont *arg2 = 0 ;
47069 void *argp1 = 0 ;
47070 int res1 = 0 ;
47071 void *argp2 = 0 ;
47072 int res2 = 0 ;
47073 PyObject * obj0 = 0 ;
47074 PyObject * obj1 = 0 ;
47075 char * kwnames[] = {
47076 (char *) "self",(char *) "font", NULL
47077 };
47078
47079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
47080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47081 if (!SWIG_IsOK(res1)) {
47082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47083 }
47084 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47085 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
47086 if (!SWIG_IsOK(res2)) {
47087 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
47088 }
47089 if (!argp2) {
47090 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
47091 }
47092 arg2 = reinterpret_cast< wxFont * >(argp2);
47093 {
47094 PyThreadState* __tstate = wxPyBeginAllowThreads();
47095 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
47096 wxPyEndAllowThreads(__tstate);
47097 if (PyErr_Occurred()) SWIG_fail;
47098 }
47099 resultobj = SWIG_Py_Void();
47100 return resultobj;
47101 fail:
47102 return NULL;
47103 }
47104
47105
47106 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47107 PyObject *resultobj = 0;
47108 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47109 wxFont result;
47110 void *argp1 = 0 ;
47111 int res1 = 0 ;
47112 PyObject *swig_obj[1] ;
47113
47114 if (!args) SWIG_fail;
47115 swig_obj[0] = args;
47116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47117 if (!SWIG_IsOK(res1)) {
47118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47119 }
47120 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47121 {
47122 PyThreadState* __tstate = wxPyBeginAllowThreads();
47123 result = wxMenuItem_GetFont(arg1);
47124 wxPyEndAllowThreads(__tstate);
47125 if (PyErr_Occurred()) SWIG_fail;
47126 }
47127 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
47128 return resultobj;
47129 fail:
47130 return NULL;
47131 }
47132
47133
47134 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47135 PyObject *resultobj = 0;
47136 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47137 wxColour *arg2 = 0 ;
47138 void *argp1 = 0 ;
47139 int res1 = 0 ;
47140 wxColour temp2 ;
47141 PyObject * obj0 = 0 ;
47142 PyObject * obj1 = 0 ;
47143 char * kwnames[] = {
47144 (char *) "self",(char *) "colText", NULL
47145 };
47146
47147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
47148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47149 if (!SWIG_IsOK(res1)) {
47150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47151 }
47152 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47153 {
47154 arg2 = &temp2;
47155 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
47156 }
47157 {
47158 PyThreadState* __tstate = wxPyBeginAllowThreads();
47159 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
47160 wxPyEndAllowThreads(__tstate);
47161 if (PyErr_Occurred()) SWIG_fail;
47162 }
47163 resultobj = SWIG_Py_Void();
47164 return resultobj;
47165 fail:
47166 return NULL;
47167 }
47168
47169
47170 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47171 PyObject *resultobj = 0;
47172 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47173 wxColour result;
47174 void *argp1 = 0 ;
47175 int res1 = 0 ;
47176 PyObject *swig_obj[1] ;
47177
47178 if (!args) SWIG_fail;
47179 swig_obj[0] = args;
47180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47181 if (!SWIG_IsOK(res1)) {
47182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47183 }
47184 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47185 {
47186 PyThreadState* __tstate = wxPyBeginAllowThreads();
47187 result = wxMenuItem_GetTextColour(arg1);
47188 wxPyEndAllowThreads(__tstate);
47189 if (PyErr_Occurred()) SWIG_fail;
47190 }
47191 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
47192 return resultobj;
47193 fail:
47194 return NULL;
47195 }
47196
47197
47198 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47199 PyObject *resultobj = 0;
47200 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47201 wxColour *arg2 = 0 ;
47202 void *argp1 = 0 ;
47203 int res1 = 0 ;
47204 wxColour temp2 ;
47205 PyObject * obj0 = 0 ;
47206 PyObject * obj1 = 0 ;
47207 char * kwnames[] = {
47208 (char *) "self",(char *) "colBack", NULL
47209 };
47210
47211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
47212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47213 if (!SWIG_IsOK(res1)) {
47214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47215 }
47216 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47217 {
47218 arg2 = &temp2;
47219 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
47220 }
47221 {
47222 PyThreadState* __tstate = wxPyBeginAllowThreads();
47223 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
47224 wxPyEndAllowThreads(__tstate);
47225 if (PyErr_Occurred()) SWIG_fail;
47226 }
47227 resultobj = SWIG_Py_Void();
47228 return resultobj;
47229 fail:
47230 return NULL;
47231 }
47232
47233
47234 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47235 PyObject *resultobj = 0;
47236 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47237 wxColour result;
47238 void *argp1 = 0 ;
47239 int res1 = 0 ;
47240 PyObject *swig_obj[1] ;
47241
47242 if (!args) SWIG_fail;
47243 swig_obj[0] = args;
47244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47245 if (!SWIG_IsOK(res1)) {
47246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47247 }
47248 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47249 {
47250 PyThreadState* __tstate = wxPyBeginAllowThreads();
47251 result = wxMenuItem_GetBackgroundColour(arg1);
47252 wxPyEndAllowThreads(__tstate);
47253 if (PyErr_Occurred()) SWIG_fail;
47254 }
47255 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
47256 return resultobj;
47257 fail:
47258 return NULL;
47259 }
47260
47261
47262 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47263 PyObject *resultobj = 0;
47264 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47265 wxBitmap *arg2 = 0 ;
47266 wxBitmap const &arg3_defvalue = wxNullBitmap ;
47267 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
47268 void *argp1 = 0 ;
47269 int res1 = 0 ;
47270 void *argp2 = 0 ;
47271 int res2 = 0 ;
47272 void *argp3 = 0 ;
47273 int res3 = 0 ;
47274 PyObject * obj0 = 0 ;
47275 PyObject * obj1 = 0 ;
47276 PyObject * obj2 = 0 ;
47277 char * kwnames[] = {
47278 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
47279 };
47280
47281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47283 if (!SWIG_IsOK(res1)) {
47284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47285 }
47286 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47287 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
47288 if (!SWIG_IsOK(res2)) {
47289 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47290 }
47291 if (!argp2) {
47292 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47293 }
47294 arg2 = reinterpret_cast< wxBitmap * >(argp2);
47295 if (obj2) {
47296 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
47297 if (!SWIG_IsOK(res3)) {
47298 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
47299 }
47300 if (!argp3) {
47301 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
47302 }
47303 arg3 = reinterpret_cast< wxBitmap * >(argp3);
47304 }
47305 {
47306 PyThreadState* __tstate = wxPyBeginAllowThreads();
47307 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
47308 wxPyEndAllowThreads(__tstate);
47309 if (PyErr_Occurred()) SWIG_fail;
47310 }
47311 resultobj = SWIG_Py_Void();
47312 return resultobj;
47313 fail:
47314 return NULL;
47315 }
47316
47317
47318 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47319 PyObject *resultobj = 0;
47320 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47321 wxBitmap *arg2 = 0 ;
47322 void *argp1 = 0 ;
47323 int res1 = 0 ;
47324 void *argp2 = 0 ;
47325 int res2 = 0 ;
47326 PyObject * obj0 = 0 ;
47327 PyObject * obj1 = 0 ;
47328 char * kwnames[] = {
47329 (char *) "self",(char *) "bmpDisabled", NULL
47330 };
47331
47332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
47333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47334 if (!SWIG_IsOK(res1)) {
47335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47336 }
47337 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47338 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
47339 if (!SWIG_IsOK(res2)) {
47340 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47341 }
47342 if (!argp2) {
47343 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47344 }
47345 arg2 = reinterpret_cast< wxBitmap * >(argp2);
47346 {
47347 PyThreadState* __tstate = wxPyBeginAllowThreads();
47348 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
47349 wxPyEndAllowThreads(__tstate);
47350 if (PyErr_Occurred()) SWIG_fail;
47351 }
47352 resultobj = SWIG_Py_Void();
47353 return resultobj;
47354 fail:
47355 return NULL;
47356 }
47357
47358
47359 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47360 PyObject *resultobj = 0;
47361 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47362 wxBitmap *result = 0 ;
47363 void *argp1 = 0 ;
47364 int res1 = 0 ;
47365 PyObject *swig_obj[1] ;
47366
47367 if (!args) SWIG_fail;
47368 swig_obj[0] = args;
47369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47370 if (!SWIG_IsOK(res1)) {
47371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47372 }
47373 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47374 {
47375 PyThreadState* __tstate = wxPyBeginAllowThreads();
47376 {
47377 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
47378 result = (wxBitmap *) &_result_ref;
47379 }
47380 wxPyEndAllowThreads(__tstate);
47381 if (PyErr_Occurred()) SWIG_fail;
47382 }
47383 {
47384 wxBitmap* resultptr = new wxBitmap(*result);
47385 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
47386 }
47387 return resultobj;
47388 fail:
47389 return NULL;
47390 }
47391
47392
47393 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47394 PyObject *resultobj = 0;
47395 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47396 int arg2 ;
47397 void *argp1 = 0 ;
47398 int res1 = 0 ;
47399 int val2 ;
47400 int ecode2 = 0 ;
47401 PyObject * obj0 = 0 ;
47402 PyObject * obj1 = 0 ;
47403 char * kwnames[] = {
47404 (char *) "self",(char *) "nWidth", NULL
47405 };
47406
47407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
47408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47409 if (!SWIG_IsOK(res1)) {
47410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47411 }
47412 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47413 ecode2 = SWIG_AsVal_int(obj1, &val2);
47414 if (!SWIG_IsOK(ecode2)) {
47415 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
47416 }
47417 arg2 = static_cast< int >(val2);
47418 {
47419 PyThreadState* __tstate = wxPyBeginAllowThreads();
47420 wxMenuItem_SetMarginWidth(arg1,arg2);
47421 wxPyEndAllowThreads(__tstate);
47422 if (PyErr_Occurred()) SWIG_fail;
47423 }
47424 resultobj = SWIG_Py_Void();
47425 return resultobj;
47426 fail:
47427 return NULL;
47428 }
47429
47430
47431 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47432 PyObject *resultobj = 0;
47433 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47434 int result;
47435 void *argp1 = 0 ;
47436 int res1 = 0 ;
47437 PyObject *swig_obj[1] ;
47438
47439 if (!args) SWIG_fail;
47440 swig_obj[0] = args;
47441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47442 if (!SWIG_IsOK(res1)) {
47443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47444 }
47445 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47446 {
47447 PyThreadState* __tstate = wxPyBeginAllowThreads();
47448 result = (int)wxMenuItem_GetMarginWidth(arg1);
47449 wxPyEndAllowThreads(__tstate);
47450 if (PyErr_Occurred()) SWIG_fail;
47451 }
47452 resultobj = SWIG_From_int(static_cast< int >(result));
47453 return resultobj;
47454 fail:
47455 return NULL;
47456 }
47457
47458
47459 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47460 PyObject *resultobj = 0;
47461 int result;
47462
47463 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
47464 {
47465 PyThreadState* __tstate = wxPyBeginAllowThreads();
47466 result = (int)wxMenuItem_GetDefaultMarginWidth();
47467 wxPyEndAllowThreads(__tstate);
47468 if (PyErr_Occurred()) SWIG_fail;
47469 }
47470 resultobj = SWIG_From_int(static_cast< int >(result));
47471 return resultobj;
47472 fail:
47473 return NULL;
47474 }
47475
47476
47477 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47478 PyObject *resultobj = 0;
47479 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47480 bool result;
47481 void *argp1 = 0 ;
47482 int res1 = 0 ;
47483 PyObject *swig_obj[1] ;
47484
47485 if (!args) SWIG_fail;
47486 swig_obj[0] = args;
47487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47488 if (!SWIG_IsOK(res1)) {
47489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47490 }
47491 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47492 {
47493 PyThreadState* __tstate = wxPyBeginAllowThreads();
47494 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
47495 wxPyEndAllowThreads(__tstate);
47496 if (PyErr_Occurred()) SWIG_fail;
47497 }
47498 {
47499 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47500 }
47501 return resultobj;
47502 fail:
47503 return NULL;
47504 }
47505
47506
47507 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47508 PyObject *resultobj = 0;
47509 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47510 bool arg2 = (bool) true ;
47511 void *argp1 = 0 ;
47512 int res1 = 0 ;
47513 bool val2 ;
47514 int ecode2 = 0 ;
47515 PyObject * obj0 = 0 ;
47516 PyObject * obj1 = 0 ;
47517 char * kwnames[] = {
47518 (char *) "self",(char *) "ownerDrawn", NULL
47519 };
47520
47521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
47522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47523 if (!SWIG_IsOK(res1)) {
47524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47525 }
47526 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47527 if (obj1) {
47528 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47529 if (!SWIG_IsOK(ecode2)) {
47530 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
47531 }
47532 arg2 = static_cast< bool >(val2);
47533 }
47534 {
47535 PyThreadState* __tstate = wxPyBeginAllowThreads();
47536 wxMenuItem_SetOwnerDrawn(arg1,arg2);
47537 wxPyEndAllowThreads(__tstate);
47538 if (PyErr_Occurred()) SWIG_fail;
47539 }
47540 resultobj = SWIG_Py_Void();
47541 return resultobj;
47542 fail:
47543 return NULL;
47544 }
47545
47546
47547 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47548 PyObject *resultobj = 0;
47549 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47550 void *argp1 = 0 ;
47551 int res1 = 0 ;
47552 PyObject *swig_obj[1] ;
47553
47554 if (!args) SWIG_fail;
47555 swig_obj[0] = args;
47556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47557 if (!SWIG_IsOK(res1)) {
47558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47559 }
47560 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47561 {
47562 PyThreadState* __tstate = wxPyBeginAllowThreads();
47563 wxMenuItem_ResetOwnerDrawn(arg1);
47564 wxPyEndAllowThreads(__tstate);
47565 if (PyErr_Occurred()) SWIG_fail;
47566 }
47567 resultobj = SWIG_Py_Void();
47568 return resultobj;
47569 fail:
47570 return NULL;
47571 }
47572
47573
47574 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47575 PyObject *obj;
47576 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47577 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
47578 return SWIG_Py_Void();
47579 }
47580
47581 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47582 return SWIG_Python_InitShadowInstance(args);
47583 }
47584
47585 SWIGINTERN int ControlNameStr_set(PyObject *) {
47586 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
47587 return 1;
47588 }
47589
47590
47591 SWIGINTERN PyObject *ControlNameStr_get(void) {
47592 PyObject *pyobj = 0;
47593
47594 {
47595 #if wxUSE_UNICODE
47596 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
47597 #else
47598 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
47599 #endif
47600 }
47601 return pyobj;
47602 }
47603
47604
47605 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47606 PyObject *resultobj = 0;
47607 wxWindow *arg1 = (wxWindow *) 0 ;
47608 int arg2 = (int) -1 ;
47609 wxPoint const &arg3_defvalue = wxDefaultPosition ;
47610 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
47611 wxSize const &arg4_defvalue = wxDefaultSize ;
47612 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
47613 long arg5 = (long) 0 ;
47614 wxValidator const &arg6_defvalue = wxDefaultValidator ;
47615 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
47616 wxString const &arg7_defvalue = wxPyControlNameStr ;
47617 wxString *arg7 = (wxString *) &arg7_defvalue ;
47618 wxControl *result = 0 ;
47619 void *argp1 = 0 ;
47620 int res1 = 0 ;
47621 int val2 ;
47622 int ecode2 = 0 ;
47623 wxPoint temp3 ;
47624 wxSize temp4 ;
47625 long val5 ;
47626 int ecode5 = 0 ;
47627 void *argp6 = 0 ;
47628 int res6 = 0 ;
47629 bool temp7 = false ;
47630 PyObject * obj0 = 0 ;
47631 PyObject * obj1 = 0 ;
47632 PyObject * obj2 = 0 ;
47633 PyObject * obj3 = 0 ;
47634 PyObject * obj4 = 0 ;
47635 PyObject * obj5 = 0 ;
47636 PyObject * obj6 = 0 ;
47637 char * kwnames[] = {
47638 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
47639 };
47640
47641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
47642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
47643 if (!SWIG_IsOK(res1)) {
47644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
47645 }
47646 arg1 = reinterpret_cast< wxWindow * >(argp1);
47647 if (obj1) {
47648 ecode2 = SWIG_AsVal_int(obj1, &val2);
47649 if (!SWIG_IsOK(ecode2)) {
47650 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
47651 }
47652 arg2 = static_cast< int >(val2);
47653 }
47654 if (obj2) {
47655 {
47656 arg3 = &temp3;
47657 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
47658 }
47659 }
47660 if (obj3) {
47661 {
47662 arg4 = &temp4;
47663 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
47664 }
47665 }
47666 if (obj4) {
47667 ecode5 = SWIG_AsVal_long(obj4, &val5);
47668 if (!SWIG_IsOK(ecode5)) {
47669 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
47670 }
47671 arg5 = static_cast< long >(val5);
47672 }
47673 if (obj5) {
47674 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
47675 if (!SWIG_IsOK(res6)) {
47676 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
47677 }
47678 if (!argp6) {
47679 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
47680 }
47681 arg6 = reinterpret_cast< wxValidator * >(argp6);
47682 }
47683 if (obj6) {
47684 {
47685 arg7 = wxString_in_helper(obj6);
47686 if (arg7 == NULL) SWIG_fail;
47687 temp7 = true;
47688 }
47689 }
47690 {
47691 if (!wxPyCheckForApp()) SWIG_fail;
47692 PyThreadState* __tstate = wxPyBeginAllowThreads();
47693 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
47694 wxPyEndAllowThreads(__tstate);
47695 if (PyErr_Occurred()) SWIG_fail;
47696 }
47697 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
47698 {
47699 if (temp7)
47700 delete arg7;
47701 }
47702 return resultobj;
47703 fail:
47704 {
47705 if (temp7)
47706 delete arg7;
47707 }
47708 return NULL;
47709 }
47710
47711
47712 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47713 PyObject *resultobj = 0;
47714 wxControl *result = 0 ;
47715
47716 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
47717 {
47718 if (!wxPyCheckForApp()) SWIG_fail;
47719 PyThreadState* __tstate = wxPyBeginAllowThreads();
47720 result = (wxControl *)new wxControl();
47721 wxPyEndAllowThreads(__tstate);
47722 if (PyErr_Occurred()) SWIG_fail;
47723 }
47724 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
47725 return resultobj;
47726 fail:
47727 return NULL;
47728 }
47729
47730
47731 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47732 PyObject *resultobj = 0;
47733 wxControl *arg1 = (wxControl *) 0 ;
47734 wxWindow *arg2 = (wxWindow *) 0 ;
47735 int arg3 = (int) -1 ;
47736 wxPoint const &arg4_defvalue = wxDefaultPosition ;
47737 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
47738 wxSize const &arg5_defvalue = wxDefaultSize ;
47739 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
47740 long arg6 = (long) 0 ;
47741 wxValidator const &arg7_defvalue = wxDefaultValidator ;
47742 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
47743 wxString const &arg8_defvalue = wxPyControlNameStr ;
47744 wxString *arg8 = (wxString *) &arg8_defvalue ;
47745 bool result;
47746 void *argp1 = 0 ;
47747 int res1 = 0 ;
47748 void *argp2 = 0 ;
47749 int res2 = 0 ;
47750 int val3 ;
47751 int ecode3 = 0 ;
47752 wxPoint temp4 ;
47753 wxSize temp5 ;
47754 long val6 ;
47755 int ecode6 = 0 ;
47756 void *argp7 = 0 ;
47757 int res7 = 0 ;
47758 bool temp8 = false ;
47759 PyObject * obj0 = 0 ;
47760 PyObject * obj1 = 0 ;
47761 PyObject * obj2 = 0 ;
47762 PyObject * obj3 = 0 ;
47763 PyObject * obj4 = 0 ;
47764 PyObject * obj5 = 0 ;
47765 PyObject * obj6 = 0 ;
47766 PyObject * obj7 = 0 ;
47767 char * kwnames[] = {
47768 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
47769 };
47770
47771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
47772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47773 if (!SWIG_IsOK(res1)) {
47774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
47775 }
47776 arg1 = reinterpret_cast< wxControl * >(argp1);
47777 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47778 if (!SWIG_IsOK(res2)) {
47779 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
47780 }
47781 arg2 = reinterpret_cast< wxWindow * >(argp2);
47782 if (obj2) {
47783 ecode3 = SWIG_AsVal_int(obj2, &val3);
47784 if (!SWIG_IsOK(ecode3)) {
47785 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
47786 }
47787 arg3 = static_cast< int >(val3);
47788 }
47789 if (obj3) {
47790 {
47791 arg4 = &temp4;
47792 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
47793 }
47794 }
47795 if (obj4) {
47796 {
47797 arg5 = &temp5;
47798 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
47799 }
47800 }
47801 if (obj5) {
47802 ecode6 = SWIG_AsVal_long(obj5, &val6);
47803 if (!SWIG_IsOK(ecode6)) {
47804 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
47805 }
47806 arg6 = static_cast< long >(val6);
47807 }
47808 if (obj6) {
47809 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
47810 if (!SWIG_IsOK(res7)) {
47811 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
47812 }
47813 if (!argp7) {
47814 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
47815 }
47816 arg7 = reinterpret_cast< wxValidator * >(argp7);
47817 }
47818 if (obj7) {
47819 {
47820 arg8 = wxString_in_helper(obj7);
47821 if (arg8 == NULL) SWIG_fail;
47822 temp8 = true;
47823 }
47824 }
47825 {
47826 PyThreadState* __tstate = wxPyBeginAllowThreads();
47827 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
47828 wxPyEndAllowThreads(__tstate);
47829 if (PyErr_Occurred()) SWIG_fail;
47830 }
47831 {
47832 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47833 }
47834 {
47835 if (temp8)
47836 delete arg8;
47837 }
47838 return resultobj;
47839 fail:
47840 {
47841 if (temp8)
47842 delete arg8;
47843 }
47844 return NULL;
47845 }
47846
47847
47848 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47849 PyObject *resultobj = 0;
47850 wxControl *arg1 = (wxControl *) 0 ;
47851 int result;
47852 void *argp1 = 0 ;
47853 int res1 = 0 ;
47854 PyObject *swig_obj[1] ;
47855
47856 if (!args) SWIG_fail;
47857 swig_obj[0] = args;
47858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47859 if (!SWIG_IsOK(res1)) {
47860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
47861 }
47862 arg1 = reinterpret_cast< wxControl * >(argp1);
47863 {
47864 PyThreadState* __tstate = wxPyBeginAllowThreads();
47865 result = (int)((wxControl const *)arg1)->GetAlignment();
47866 wxPyEndAllowThreads(__tstate);
47867 if (PyErr_Occurred()) SWIG_fail;
47868 }
47869 resultobj = SWIG_From_int(static_cast< int >(result));
47870 return resultobj;
47871 fail:
47872 return NULL;
47873 }
47874
47875
47876 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47877 PyObject *resultobj = 0;
47878 wxControl *arg1 = (wxControl *) 0 ;
47879 wxString result;
47880 void *argp1 = 0 ;
47881 int res1 = 0 ;
47882 PyObject *swig_obj[1] ;
47883
47884 if (!args) SWIG_fail;
47885 swig_obj[0] = args;
47886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47887 if (!SWIG_IsOK(res1)) {
47888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
47889 }
47890 arg1 = reinterpret_cast< wxControl * >(argp1);
47891 {
47892 PyThreadState* __tstate = wxPyBeginAllowThreads();
47893 result = ((wxControl const *)arg1)->GetLabelText();
47894 wxPyEndAllowThreads(__tstate);
47895 if (PyErr_Occurred()) SWIG_fail;
47896 }
47897 {
47898 #if wxUSE_UNICODE
47899 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
47900 #else
47901 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
47902 #endif
47903 }
47904 return resultobj;
47905 fail:
47906 return NULL;
47907 }
47908
47909
47910 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47911 PyObject *resultobj = 0;
47912 wxControl *arg1 = (wxControl *) 0 ;
47913 wxCommandEvent *arg2 = 0 ;
47914 void *argp1 = 0 ;
47915 int res1 = 0 ;
47916 void *argp2 = 0 ;
47917 int res2 = 0 ;
47918 PyObject * obj0 = 0 ;
47919 PyObject * obj1 = 0 ;
47920 char * kwnames[] = {
47921 (char *) "self",(char *) "event", NULL
47922 };
47923
47924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
47925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47926 if (!SWIG_IsOK(res1)) {
47927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
47928 }
47929 arg1 = reinterpret_cast< wxControl * >(argp1);
47930 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
47931 if (!SWIG_IsOK(res2)) {
47932 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
47933 }
47934 if (!argp2) {
47935 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
47936 }
47937 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
47938 {
47939 PyThreadState* __tstate = wxPyBeginAllowThreads();
47940 (arg1)->Command(*arg2);
47941 wxPyEndAllowThreads(__tstate);
47942 if (PyErr_Occurred()) SWIG_fail;
47943 }
47944 resultobj = SWIG_Py_Void();
47945 return resultobj;
47946 fail:
47947 return NULL;
47948 }
47949
47950
47951 SWIGINTERN PyObject *_wrap_Control_RemoveMnemonics(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47952 PyObject *resultobj = 0;
47953 wxString *arg1 = 0 ;
47954 wxString result;
47955 bool temp1 = false ;
47956 PyObject * obj0 = 0 ;
47957 char * kwnames[] = {
47958 (char *) "str", NULL
47959 };
47960
47961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_RemoveMnemonics",kwnames,&obj0)) SWIG_fail;
47962 {
47963 arg1 = wxString_in_helper(obj0);
47964 if (arg1 == NULL) SWIG_fail;
47965 temp1 = true;
47966 }
47967 {
47968 PyThreadState* __tstate = wxPyBeginAllowThreads();
47969 result = wxControl::RemoveMnemonics((wxString const &)*arg1);
47970 wxPyEndAllowThreads(__tstate);
47971 if (PyErr_Occurred()) SWIG_fail;
47972 }
47973 {
47974 #if wxUSE_UNICODE
47975 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
47976 #else
47977 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
47978 #endif
47979 }
47980 {
47981 if (temp1)
47982 delete arg1;
47983 }
47984 return resultobj;
47985 fail:
47986 {
47987 if (temp1)
47988 delete arg1;
47989 }
47990 return NULL;
47991 }
47992
47993
47994 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47995 PyObject *resultobj = 0;
47996 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
47997 SwigValueWrapper<wxVisualAttributes > result;
47998 int val1 ;
47999 int ecode1 = 0 ;
48000 PyObject * obj0 = 0 ;
48001 char * kwnames[] = {
48002 (char *) "variant", NULL
48003 };
48004
48005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
48006 if (obj0) {
48007 ecode1 = SWIG_AsVal_int(obj0, &val1);
48008 if (!SWIG_IsOK(ecode1)) {
48009 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
48010 }
48011 arg1 = static_cast< wxWindowVariant >(val1);
48012 }
48013 {
48014 if (!wxPyCheckForApp()) SWIG_fail;
48015 PyThreadState* __tstate = wxPyBeginAllowThreads();
48016 result = wxControl::GetClassDefaultAttributes(arg1);
48017 wxPyEndAllowThreads(__tstate);
48018 if (PyErr_Occurred()) SWIG_fail;
48019 }
48020 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
48021 return resultobj;
48022 fail:
48023 return NULL;
48024 }
48025
48026
48027 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48028 PyObject *obj;
48029 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48030 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
48031 return SWIG_Py_Void();
48032 }
48033
48034 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48035 return SWIG_Python_InitShadowInstance(args);
48036 }
48037
48038 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48039 PyObject *resultobj = 0;
48040 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48041 wxString *arg2 = 0 ;
48042 PyObject *arg3 = (PyObject *) NULL ;
48043 int result;
48044 void *argp1 = 0 ;
48045 int res1 = 0 ;
48046 bool temp2 = false ;
48047 PyObject * obj0 = 0 ;
48048 PyObject * obj1 = 0 ;
48049 PyObject * obj2 = 0 ;
48050 char * kwnames[] = {
48051 (char *) "self",(char *) "item",(char *) "clientData", NULL
48052 };
48053
48054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48056 if (!SWIG_IsOK(res1)) {
48057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48058 }
48059 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48060 {
48061 arg2 = wxString_in_helper(obj1);
48062 if (arg2 == NULL) SWIG_fail;
48063 temp2 = true;
48064 }
48065 if (obj2) {
48066 arg3 = obj2;
48067 }
48068 {
48069 PyThreadState* __tstate = wxPyBeginAllowThreads();
48070 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
48071 wxPyEndAllowThreads(__tstate);
48072 if (PyErr_Occurred()) SWIG_fail;
48073 }
48074 resultobj = SWIG_From_int(static_cast< int >(result));
48075 {
48076 if (temp2)
48077 delete arg2;
48078 }
48079 return resultobj;
48080 fail:
48081 {
48082 if (temp2)
48083 delete arg2;
48084 }
48085 return NULL;
48086 }
48087
48088
48089 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48090 PyObject *resultobj = 0;
48091 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48092 wxArrayString *arg2 = 0 ;
48093 void *argp1 = 0 ;
48094 int res1 = 0 ;
48095 bool temp2 = false ;
48096 PyObject * obj0 = 0 ;
48097 PyObject * obj1 = 0 ;
48098 char * kwnames[] = {
48099 (char *) "self",(char *) "strings", NULL
48100 };
48101
48102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
48103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48104 if (!SWIG_IsOK(res1)) {
48105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48106 }
48107 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48108 {
48109 if (! PySequence_Check(obj1)) {
48110 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
48111 SWIG_fail;
48112 }
48113 arg2 = new wxArrayString;
48114 temp2 = true;
48115 int i, len=PySequence_Length(obj1);
48116 for (i=0; i<len; i++) {
48117 PyObject* item = PySequence_GetItem(obj1, i);
48118 wxString* s = wxString_in_helper(item);
48119 if (PyErr_Occurred()) SWIG_fail;
48120 arg2->Add(*s);
48121 delete s;
48122 Py_DECREF(item);
48123 }
48124 }
48125 {
48126 PyThreadState* __tstate = wxPyBeginAllowThreads();
48127 (arg1)->Append((wxArrayString const &)*arg2);
48128 wxPyEndAllowThreads(__tstate);
48129 if (PyErr_Occurred()) SWIG_fail;
48130 }
48131 resultobj = SWIG_Py_Void();
48132 {
48133 if (temp2) delete arg2;
48134 }
48135 return resultobj;
48136 fail:
48137 {
48138 if (temp2) delete arg2;
48139 }
48140 return NULL;
48141 }
48142
48143
48144 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48145 PyObject *resultobj = 0;
48146 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48147 wxString *arg2 = 0 ;
48148 int arg3 ;
48149 PyObject *arg4 = (PyObject *) NULL ;
48150 int result;
48151 void *argp1 = 0 ;
48152 int res1 = 0 ;
48153 bool temp2 = false ;
48154 int val3 ;
48155 int ecode3 = 0 ;
48156 PyObject * obj0 = 0 ;
48157 PyObject * obj1 = 0 ;
48158 PyObject * obj2 = 0 ;
48159 PyObject * obj3 = 0 ;
48160 char * kwnames[] = {
48161 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
48162 };
48163
48164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48165 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48166 if (!SWIG_IsOK(res1)) {
48167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48168 }
48169 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48170 {
48171 arg2 = wxString_in_helper(obj1);
48172 if (arg2 == NULL) SWIG_fail;
48173 temp2 = true;
48174 }
48175 ecode3 = SWIG_AsVal_int(obj2, &val3);
48176 if (!SWIG_IsOK(ecode3)) {
48177 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "int""'");
48178 }
48179 arg3 = static_cast< int >(val3);
48180 if (obj3) {
48181 arg4 = obj3;
48182 }
48183 {
48184 PyThreadState* __tstate = wxPyBeginAllowThreads();
48185 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
48186 wxPyEndAllowThreads(__tstate);
48187 if (PyErr_Occurred()) SWIG_fail;
48188 }
48189 resultobj = SWIG_From_int(static_cast< int >(result));
48190 {
48191 if (temp2)
48192 delete arg2;
48193 }
48194 return resultobj;
48195 fail:
48196 {
48197 if (temp2)
48198 delete arg2;
48199 }
48200 return NULL;
48201 }
48202
48203
48204 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48205 PyObject *resultobj = 0;
48206 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48207 void *argp1 = 0 ;
48208 int res1 = 0 ;
48209 PyObject *swig_obj[1] ;
48210
48211 if (!args) SWIG_fail;
48212 swig_obj[0] = args;
48213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48214 if (!SWIG_IsOK(res1)) {
48215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48216 }
48217 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48218 {
48219 PyThreadState* __tstate = wxPyBeginAllowThreads();
48220 (arg1)->Clear();
48221 wxPyEndAllowThreads(__tstate);
48222 if (PyErr_Occurred()) SWIG_fail;
48223 }
48224 resultobj = SWIG_Py_Void();
48225 return resultobj;
48226 fail:
48227 return NULL;
48228 }
48229
48230
48231 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48232 PyObject *resultobj = 0;
48233 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48234 int arg2 ;
48235 void *argp1 = 0 ;
48236 int res1 = 0 ;
48237 int val2 ;
48238 int ecode2 = 0 ;
48239 PyObject * obj0 = 0 ;
48240 PyObject * obj1 = 0 ;
48241 char * kwnames[] = {
48242 (char *) "self",(char *) "n", NULL
48243 };
48244
48245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
48246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48247 if (!SWIG_IsOK(res1)) {
48248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48249 }
48250 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48251 ecode2 = SWIG_AsVal_int(obj1, &val2);
48252 if (!SWIG_IsOK(ecode2)) {
48253 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "int""'");
48254 }
48255 arg2 = static_cast< int >(val2);
48256 {
48257 PyThreadState* __tstate = wxPyBeginAllowThreads();
48258 (arg1)->Delete(arg2);
48259 wxPyEndAllowThreads(__tstate);
48260 if (PyErr_Occurred()) SWIG_fail;
48261 }
48262 resultobj = SWIG_Py_Void();
48263 return resultobj;
48264 fail:
48265 return NULL;
48266 }
48267
48268
48269 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48270 PyObject *resultobj = 0;
48271 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48272 int arg2 ;
48273 PyObject *result = 0 ;
48274 void *argp1 = 0 ;
48275 int res1 = 0 ;
48276 int val2 ;
48277 int ecode2 = 0 ;
48278 PyObject * obj0 = 0 ;
48279 PyObject * obj1 = 0 ;
48280 char * kwnames[] = {
48281 (char *) "self",(char *) "n", NULL
48282 };
48283
48284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
48285 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48286 if (!SWIG_IsOK(res1)) {
48287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48288 }
48289 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48290 ecode2 = SWIG_AsVal_int(obj1, &val2);
48291 if (!SWIG_IsOK(ecode2)) {
48292 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "int""'");
48293 }
48294 arg2 = static_cast< int >(val2);
48295 {
48296 PyThreadState* __tstate = wxPyBeginAllowThreads();
48297 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
48298 wxPyEndAllowThreads(__tstate);
48299 if (PyErr_Occurred()) SWIG_fail;
48300 }
48301 resultobj = result;
48302 return resultobj;
48303 fail:
48304 return NULL;
48305 }
48306
48307
48308 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48309 PyObject *resultobj = 0;
48310 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48311 int arg2 ;
48312 PyObject *arg3 = (PyObject *) 0 ;
48313 void *argp1 = 0 ;
48314 int res1 = 0 ;
48315 int val2 ;
48316 int ecode2 = 0 ;
48317 PyObject * obj0 = 0 ;
48318 PyObject * obj1 = 0 ;
48319 PyObject * obj2 = 0 ;
48320 char * kwnames[] = {
48321 (char *) "self",(char *) "n",(char *) "clientData", NULL
48322 };
48323
48324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48326 if (!SWIG_IsOK(res1)) {
48327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48328 }
48329 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48330 ecode2 = SWIG_AsVal_int(obj1, &val2);
48331 if (!SWIG_IsOK(ecode2)) {
48332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "int""'");
48333 }
48334 arg2 = static_cast< int >(val2);
48335 arg3 = obj2;
48336 {
48337 PyThreadState* __tstate = wxPyBeginAllowThreads();
48338 wxItemContainer_SetClientData(arg1,arg2,arg3);
48339 wxPyEndAllowThreads(__tstate);
48340 if (PyErr_Occurred()) SWIG_fail;
48341 }
48342 resultobj = SWIG_Py_Void();
48343 return resultobj;
48344 fail:
48345 return NULL;
48346 }
48347
48348
48349 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48350 PyObject *resultobj = 0;
48351 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48352 int result;
48353 void *argp1 = 0 ;
48354 int res1 = 0 ;
48355 PyObject *swig_obj[1] ;
48356
48357 if (!args) SWIG_fail;
48358 swig_obj[0] = args;
48359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48360 if (!SWIG_IsOK(res1)) {
48361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48362 }
48363 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48364 {
48365 PyThreadState* __tstate = wxPyBeginAllowThreads();
48366 result = (int)((wxItemContainer const *)arg1)->GetCount();
48367 wxPyEndAllowThreads(__tstate);
48368 if (PyErr_Occurred()) SWIG_fail;
48369 }
48370 resultobj = SWIG_From_int(static_cast< int >(result));
48371 return resultobj;
48372 fail:
48373 return NULL;
48374 }
48375
48376
48377 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48378 PyObject *resultobj = 0;
48379 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48380 bool result;
48381 void *argp1 = 0 ;
48382 int res1 = 0 ;
48383 PyObject *swig_obj[1] ;
48384
48385 if (!args) SWIG_fail;
48386 swig_obj[0] = args;
48387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48388 if (!SWIG_IsOK(res1)) {
48389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48390 }
48391 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48392 {
48393 PyThreadState* __tstate = wxPyBeginAllowThreads();
48394 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
48395 wxPyEndAllowThreads(__tstate);
48396 if (PyErr_Occurred()) SWIG_fail;
48397 }
48398 {
48399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48400 }
48401 return resultobj;
48402 fail:
48403 return NULL;
48404 }
48405
48406
48407 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48408 PyObject *resultobj = 0;
48409 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48410 int arg2 ;
48411 wxString result;
48412 void *argp1 = 0 ;
48413 int res1 = 0 ;
48414 int val2 ;
48415 int ecode2 = 0 ;
48416 PyObject * obj0 = 0 ;
48417 PyObject * obj1 = 0 ;
48418 char * kwnames[] = {
48419 (char *) "self",(char *) "n", NULL
48420 };
48421
48422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
48423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48424 if (!SWIG_IsOK(res1)) {
48425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48426 }
48427 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48428 ecode2 = SWIG_AsVal_int(obj1, &val2);
48429 if (!SWIG_IsOK(ecode2)) {
48430 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "int""'");
48431 }
48432 arg2 = static_cast< int >(val2);
48433 {
48434 PyThreadState* __tstate = wxPyBeginAllowThreads();
48435 result = ((wxItemContainer const *)arg1)->GetString(arg2);
48436 wxPyEndAllowThreads(__tstate);
48437 if (PyErr_Occurred()) SWIG_fail;
48438 }
48439 {
48440 #if wxUSE_UNICODE
48441 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48442 #else
48443 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48444 #endif
48445 }
48446 return resultobj;
48447 fail:
48448 return NULL;
48449 }
48450
48451
48452 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48453 PyObject *resultobj = 0;
48454 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48455 wxArrayString result;
48456 void *argp1 = 0 ;
48457 int res1 = 0 ;
48458 PyObject *swig_obj[1] ;
48459
48460 if (!args) SWIG_fail;
48461 swig_obj[0] = args;
48462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48463 if (!SWIG_IsOK(res1)) {
48464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48465 }
48466 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48467 {
48468 PyThreadState* __tstate = wxPyBeginAllowThreads();
48469 result = ((wxItemContainer const *)arg1)->GetStrings();
48470 wxPyEndAllowThreads(__tstate);
48471 if (PyErr_Occurred()) SWIG_fail;
48472 }
48473 {
48474 resultobj = wxArrayString2PyList_helper(result);
48475 }
48476 return resultobj;
48477 fail:
48478 return NULL;
48479 }
48480
48481
48482 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48483 PyObject *resultobj = 0;
48484 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48485 int arg2 ;
48486 wxString *arg3 = 0 ;
48487 void *argp1 = 0 ;
48488 int res1 = 0 ;
48489 int val2 ;
48490 int ecode2 = 0 ;
48491 bool temp3 = false ;
48492 PyObject * obj0 = 0 ;
48493 PyObject * obj1 = 0 ;
48494 PyObject * obj2 = 0 ;
48495 char * kwnames[] = {
48496 (char *) "self",(char *) "n",(char *) "s", NULL
48497 };
48498
48499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48501 if (!SWIG_IsOK(res1)) {
48502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48503 }
48504 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48505 ecode2 = SWIG_AsVal_int(obj1, &val2);
48506 if (!SWIG_IsOK(ecode2)) {
48507 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "int""'");
48508 }
48509 arg2 = static_cast< int >(val2);
48510 {
48511 arg3 = wxString_in_helper(obj2);
48512 if (arg3 == NULL) SWIG_fail;
48513 temp3 = true;
48514 }
48515 {
48516 PyThreadState* __tstate = wxPyBeginAllowThreads();
48517 (arg1)->SetString(arg2,(wxString const &)*arg3);
48518 wxPyEndAllowThreads(__tstate);
48519 if (PyErr_Occurred()) SWIG_fail;
48520 }
48521 resultobj = SWIG_Py_Void();
48522 {
48523 if (temp3)
48524 delete arg3;
48525 }
48526 return resultobj;
48527 fail:
48528 {
48529 if (temp3)
48530 delete arg3;
48531 }
48532 return NULL;
48533 }
48534
48535
48536 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48537 PyObject *resultobj = 0;
48538 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48539 wxString *arg2 = 0 ;
48540 int result;
48541 void *argp1 = 0 ;
48542 int res1 = 0 ;
48543 bool temp2 = false ;
48544 PyObject * obj0 = 0 ;
48545 PyObject * obj1 = 0 ;
48546 char * kwnames[] = {
48547 (char *) "self",(char *) "s", NULL
48548 };
48549
48550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
48551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48552 if (!SWIG_IsOK(res1)) {
48553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48554 }
48555 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48556 {
48557 arg2 = wxString_in_helper(obj1);
48558 if (arg2 == NULL) SWIG_fail;
48559 temp2 = true;
48560 }
48561 {
48562 PyThreadState* __tstate = wxPyBeginAllowThreads();
48563 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
48564 wxPyEndAllowThreads(__tstate);
48565 if (PyErr_Occurred()) SWIG_fail;
48566 }
48567 resultobj = SWIG_From_int(static_cast< int >(result));
48568 {
48569 if (temp2)
48570 delete arg2;
48571 }
48572 return resultobj;
48573 fail:
48574 {
48575 if (temp2)
48576 delete arg2;
48577 }
48578 return NULL;
48579 }
48580
48581
48582 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48583 PyObject *resultobj = 0;
48584 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48585 int arg2 ;
48586 void *argp1 = 0 ;
48587 int res1 = 0 ;
48588 int val2 ;
48589 int ecode2 = 0 ;
48590 PyObject * obj0 = 0 ;
48591 PyObject * obj1 = 0 ;
48592 char * kwnames[] = {
48593 (char *) "self",(char *) "n", NULL
48594 };
48595
48596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
48597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48598 if (!SWIG_IsOK(res1)) {
48599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48600 }
48601 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48602 ecode2 = SWIG_AsVal_int(obj1, &val2);
48603 if (!SWIG_IsOK(ecode2)) {
48604 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
48605 }
48606 arg2 = static_cast< int >(val2);
48607 {
48608 PyThreadState* __tstate = wxPyBeginAllowThreads();
48609 (arg1)->SetSelection(arg2);
48610 wxPyEndAllowThreads(__tstate);
48611 if (PyErr_Occurred()) SWIG_fail;
48612 }
48613 resultobj = SWIG_Py_Void();
48614 return resultobj;
48615 fail:
48616 return NULL;
48617 }
48618
48619
48620 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48621 PyObject *resultobj = 0;
48622 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48623 int result;
48624 void *argp1 = 0 ;
48625 int res1 = 0 ;
48626 PyObject *swig_obj[1] ;
48627
48628 if (!args) SWIG_fail;
48629 swig_obj[0] = args;
48630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48631 if (!SWIG_IsOK(res1)) {
48632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48633 }
48634 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48635 {
48636 PyThreadState* __tstate = wxPyBeginAllowThreads();
48637 result = (int)((wxItemContainer const *)arg1)->GetSelection();
48638 wxPyEndAllowThreads(__tstate);
48639 if (PyErr_Occurred()) SWIG_fail;
48640 }
48641 resultobj = SWIG_From_int(static_cast< int >(result));
48642 return resultobj;
48643 fail:
48644 return NULL;
48645 }
48646
48647
48648 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48649 PyObject *resultobj = 0;
48650 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48651 wxString *arg2 = 0 ;
48652 bool result;
48653 void *argp1 = 0 ;
48654 int res1 = 0 ;
48655 bool temp2 = false ;
48656 PyObject * obj0 = 0 ;
48657 PyObject * obj1 = 0 ;
48658 char * kwnames[] = {
48659 (char *) "self",(char *) "s", NULL
48660 };
48661
48662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
48663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48664 if (!SWIG_IsOK(res1)) {
48665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48666 }
48667 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48668 {
48669 arg2 = wxString_in_helper(obj1);
48670 if (arg2 == NULL) SWIG_fail;
48671 temp2 = true;
48672 }
48673 {
48674 PyThreadState* __tstate = wxPyBeginAllowThreads();
48675 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
48676 wxPyEndAllowThreads(__tstate);
48677 if (PyErr_Occurred()) SWIG_fail;
48678 }
48679 {
48680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48681 }
48682 {
48683 if (temp2)
48684 delete arg2;
48685 }
48686 return resultobj;
48687 fail:
48688 {
48689 if (temp2)
48690 delete arg2;
48691 }
48692 return NULL;
48693 }
48694
48695
48696 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48697 PyObject *resultobj = 0;
48698 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48699 wxString result;
48700 void *argp1 = 0 ;
48701 int res1 = 0 ;
48702 PyObject *swig_obj[1] ;
48703
48704 if (!args) SWIG_fail;
48705 swig_obj[0] = args;
48706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48707 if (!SWIG_IsOK(res1)) {
48708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48709 }
48710 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48711 {
48712 PyThreadState* __tstate = wxPyBeginAllowThreads();
48713 result = ((wxItemContainer const *)arg1)->GetStringSelection();
48714 wxPyEndAllowThreads(__tstate);
48715 if (PyErr_Occurred()) SWIG_fail;
48716 }
48717 {
48718 #if wxUSE_UNICODE
48719 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48720 #else
48721 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48722 #endif
48723 }
48724 return resultobj;
48725 fail:
48726 return NULL;
48727 }
48728
48729
48730 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48731 PyObject *resultobj = 0;
48732 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48733 int arg2 ;
48734 void *argp1 = 0 ;
48735 int res1 = 0 ;
48736 int val2 ;
48737 int ecode2 = 0 ;
48738 PyObject * obj0 = 0 ;
48739 PyObject * obj1 = 0 ;
48740 char * kwnames[] = {
48741 (char *) "self",(char *) "n", NULL
48742 };
48743
48744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
48745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48746 if (!SWIG_IsOK(res1)) {
48747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48748 }
48749 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48750 ecode2 = SWIG_AsVal_int(obj1, &val2);
48751 if (!SWIG_IsOK(ecode2)) {
48752 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
48753 }
48754 arg2 = static_cast< int >(val2);
48755 {
48756 PyThreadState* __tstate = wxPyBeginAllowThreads();
48757 (arg1)->Select(arg2);
48758 wxPyEndAllowThreads(__tstate);
48759 if (PyErr_Occurred()) SWIG_fail;
48760 }
48761 resultobj = SWIG_Py_Void();
48762 return resultobj;
48763 fail:
48764 return NULL;
48765 }
48766
48767
48768 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48769 PyObject *obj;
48770 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48771 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
48772 return SWIG_Py_Void();
48773 }
48774
48775 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48776 PyObject *obj;
48777 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48778 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
48779 return SWIG_Py_Void();
48780 }
48781
48782 SWIGINTERN PyObject *_wrap_new_SizerFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48783 PyObject *resultobj = 0;
48784 int arg1 = (int) 0 ;
48785 wxSizerFlags *result = 0 ;
48786 int val1 ;
48787 int ecode1 = 0 ;
48788 PyObject * obj0 = 0 ;
48789 char * kwnames[] = {
48790 (char *) "proportion", NULL
48791 };
48792
48793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_SizerFlags",kwnames,&obj0)) SWIG_fail;
48794 if (obj0) {
48795 ecode1 = SWIG_AsVal_int(obj0, &val1);
48796 if (!SWIG_IsOK(ecode1)) {
48797 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerFlags" "', expected argument " "1"" of type '" "int""'");
48798 }
48799 arg1 = static_cast< int >(val1);
48800 }
48801 {
48802 PyThreadState* __tstate = wxPyBeginAllowThreads();
48803 result = (wxSizerFlags *)new wxSizerFlags(arg1);
48804 wxPyEndAllowThreads(__tstate);
48805 if (PyErr_Occurred()) SWIG_fail;
48806 }
48807 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerFlags, SWIG_POINTER_NEW | 0 );
48808 return resultobj;
48809 fail:
48810 return NULL;
48811 }
48812
48813
48814 SWIGINTERN PyObject *_wrap_delete_SizerFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48815 PyObject *resultobj = 0;
48816 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
48817 void *argp1 = 0 ;
48818 int res1 = 0 ;
48819 PyObject *swig_obj[1] ;
48820
48821 if (!args) SWIG_fail;
48822 swig_obj[0] = args;
48823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, SWIG_POINTER_DISOWN | 0 );
48824 if (!SWIG_IsOK(res1)) {
48825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerFlags" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
48826 }
48827 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
48828 {
48829 PyThreadState* __tstate = wxPyBeginAllowThreads();
48830 delete arg1;
48831
48832 wxPyEndAllowThreads(__tstate);
48833 if (PyErr_Occurred()) SWIG_fail;
48834 }
48835 resultobj = SWIG_Py_Void();
48836 return resultobj;
48837 fail:
48838 return NULL;
48839 }
48840
48841
48842 SWIGINTERN PyObject *_wrap_SizerFlags_Proportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48843 PyObject *resultobj = 0;
48844 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
48845 int arg2 ;
48846 wxSizerFlags *result = 0 ;
48847 void *argp1 = 0 ;
48848 int res1 = 0 ;
48849 int val2 ;
48850 int ecode2 = 0 ;
48851 PyObject * obj0 = 0 ;
48852 PyObject * obj1 = 0 ;
48853 char * kwnames[] = {
48854 (char *) "self",(char *) "proportion", NULL
48855 };
48856
48857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerFlags_Proportion",kwnames,&obj0,&obj1)) SWIG_fail;
48858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
48859 if (!SWIG_IsOK(res1)) {
48860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Proportion" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
48861 }
48862 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
48863 ecode2 = SWIG_AsVal_int(obj1, &val2);
48864 if (!SWIG_IsOK(ecode2)) {
48865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerFlags_Proportion" "', expected argument " "2"" of type '" "int""'");
48866 }
48867 arg2 = static_cast< int >(val2);
48868 {
48869 PyThreadState* __tstate = wxPyBeginAllowThreads();
48870 {
48871 wxSizerFlags &_result_ref = (arg1)->Proportion(arg2);
48872 result = (wxSizerFlags *) &_result_ref;
48873 }
48874 wxPyEndAllowThreads(__tstate);
48875 if (PyErr_Occurred()) SWIG_fail;
48876 }
48877 {
48878 resultobj = obj0; Py_INCREF(resultobj);
48879 }
48880 return resultobj;
48881 fail:
48882 return NULL;
48883 }
48884
48885
48886 SWIGINTERN PyObject *_wrap_SizerFlags_Align(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48887 PyObject *resultobj = 0;
48888 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
48889 int arg2 ;
48890 wxSizerFlags *result = 0 ;
48891 void *argp1 = 0 ;
48892 int res1 = 0 ;
48893 int val2 ;
48894 int ecode2 = 0 ;
48895 PyObject * obj0 = 0 ;
48896 PyObject * obj1 = 0 ;
48897 char * kwnames[] = {
48898 (char *) "self",(char *) "alignment", NULL
48899 };
48900
48901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerFlags_Align",kwnames,&obj0,&obj1)) SWIG_fail;
48902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
48903 if (!SWIG_IsOK(res1)) {
48904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Align" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
48905 }
48906 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
48907 ecode2 = SWIG_AsVal_int(obj1, &val2);
48908 if (!SWIG_IsOK(ecode2)) {
48909 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerFlags_Align" "', expected argument " "2"" of type '" "int""'");
48910 }
48911 arg2 = static_cast< int >(val2);
48912 {
48913 PyThreadState* __tstate = wxPyBeginAllowThreads();
48914 {
48915 wxSizerFlags &_result_ref = (arg1)->Align(arg2);
48916 result = (wxSizerFlags *) &_result_ref;
48917 }
48918 wxPyEndAllowThreads(__tstate);
48919 if (PyErr_Occurred()) SWIG_fail;
48920 }
48921 {
48922 resultobj = obj0; Py_INCREF(resultobj);
48923 }
48924 return resultobj;
48925 fail:
48926 return NULL;
48927 }
48928
48929
48930 SWIGINTERN PyObject *_wrap_SizerFlags_Expand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48931 PyObject *resultobj = 0;
48932 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
48933 wxSizerFlags *result = 0 ;
48934 void *argp1 = 0 ;
48935 int res1 = 0 ;
48936 PyObject *swig_obj[1] ;
48937
48938 if (!args) SWIG_fail;
48939 swig_obj[0] = args;
48940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
48941 if (!SWIG_IsOK(res1)) {
48942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Expand" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
48943 }
48944 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
48945 {
48946 PyThreadState* __tstate = wxPyBeginAllowThreads();
48947 {
48948 wxSizerFlags &_result_ref = (arg1)->Expand();
48949 result = (wxSizerFlags *) &_result_ref;
48950 }
48951 wxPyEndAllowThreads(__tstate);
48952 if (PyErr_Occurred()) SWIG_fail;
48953 }
48954 {
48955 resultobj = swig_obj[0]; Py_INCREF(resultobj);
48956 }
48957 return resultobj;
48958 fail:
48959 return NULL;
48960 }
48961
48962
48963 SWIGINTERN PyObject *_wrap_SizerFlags_Centre(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48964 PyObject *resultobj = 0;
48965 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
48966 wxSizerFlags *result = 0 ;
48967 void *argp1 = 0 ;
48968 int res1 = 0 ;
48969 PyObject *swig_obj[1] ;
48970
48971 if (!args) SWIG_fail;
48972 swig_obj[0] = args;
48973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
48974 if (!SWIG_IsOK(res1)) {
48975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Centre" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
48976 }
48977 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
48978 {
48979 PyThreadState* __tstate = wxPyBeginAllowThreads();
48980 {
48981 wxSizerFlags &_result_ref = (arg1)->Centre();
48982 result = (wxSizerFlags *) &_result_ref;
48983 }
48984 wxPyEndAllowThreads(__tstate);
48985 if (PyErr_Occurred()) SWIG_fail;
48986 }
48987 {
48988 resultobj = swig_obj[0]; Py_INCREF(resultobj);
48989 }
48990 return resultobj;
48991 fail:
48992 return NULL;
48993 }
48994
48995
48996 SWIGINTERN PyObject *_wrap_SizerFlags_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48997 PyObject *resultobj = 0;
48998 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
48999 wxSizerFlags *result = 0 ;
49000 void *argp1 = 0 ;
49001 int res1 = 0 ;
49002 PyObject *swig_obj[1] ;
49003
49004 if (!args) SWIG_fail;
49005 swig_obj[0] = args;
49006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49007 if (!SWIG_IsOK(res1)) {
49008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Center" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49009 }
49010 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49011 {
49012 PyThreadState* __tstate = wxPyBeginAllowThreads();
49013 {
49014 wxSizerFlags &_result_ref = (arg1)->Center();
49015 result = (wxSizerFlags *) &_result_ref;
49016 }
49017 wxPyEndAllowThreads(__tstate);
49018 if (PyErr_Occurred()) SWIG_fail;
49019 }
49020 {
49021 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49022 }
49023 return resultobj;
49024 fail:
49025 return NULL;
49026 }
49027
49028
49029 SWIGINTERN PyObject *_wrap_SizerFlags_Left(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49030 PyObject *resultobj = 0;
49031 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49032 wxSizerFlags *result = 0 ;
49033 void *argp1 = 0 ;
49034 int res1 = 0 ;
49035 PyObject *swig_obj[1] ;
49036
49037 if (!args) SWIG_fail;
49038 swig_obj[0] = args;
49039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49040 if (!SWIG_IsOK(res1)) {
49041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Left" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49042 }
49043 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49044 {
49045 PyThreadState* __tstate = wxPyBeginAllowThreads();
49046 {
49047 wxSizerFlags &_result_ref = (arg1)->Left();
49048 result = (wxSizerFlags *) &_result_ref;
49049 }
49050 wxPyEndAllowThreads(__tstate);
49051 if (PyErr_Occurred()) SWIG_fail;
49052 }
49053 {
49054 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49055 }
49056 return resultobj;
49057 fail:
49058 return NULL;
49059 }
49060
49061
49062 SWIGINTERN PyObject *_wrap_SizerFlags_Right(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49063 PyObject *resultobj = 0;
49064 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49065 wxSizerFlags *result = 0 ;
49066 void *argp1 = 0 ;
49067 int res1 = 0 ;
49068 PyObject *swig_obj[1] ;
49069
49070 if (!args) SWIG_fail;
49071 swig_obj[0] = args;
49072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49073 if (!SWIG_IsOK(res1)) {
49074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Right" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49075 }
49076 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49077 {
49078 PyThreadState* __tstate = wxPyBeginAllowThreads();
49079 {
49080 wxSizerFlags &_result_ref = (arg1)->Right();
49081 result = (wxSizerFlags *) &_result_ref;
49082 }
49083 wxPyEndAllowThreads(__tstate);
49084 if (PyErr_Occurred()) SWIG_fail;
49085 }
49086 {
49087 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49088 }
49089 return resultobj;
49090 fail:
49091 return NULL;
49092 }
49093
49094
49095 SWIGINTERN PyObject *_wrap_SizerFlags_Top(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49096 PyObject *resultobj = 0;
49097 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49098 wxSizerFlags *result = 0 ;
49099 void *argp1 = 0 ;
49100 int res1 = 0 ;
49101 PyObject *swig_obj[1] ;
49102
49103 if (!args) SWIG_fail;
49104 swig_obj[0] = args;
49105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49106 if (!SWIG_IsOK(res1)) {
49107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Top" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49108 }
49109 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49110 {
49111 PyThreadState* __tstate = wxPyBeginAllowThreads();
49112 {
49113 wxSizerFlags &_result_ref = (arg1)->Top();
49114 result = (wxSizerFlags *) &_result_ref;
49115 }
49116 wxPyEndAllowThreads(__tstate);
49117 if (PyErr_Occurred()) SWIG_fail;
49118 }
49119 {
49120 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49121 }
49122 return resultobj;
49123 fail:
49124 return NULL;
49125 }
49126
49127
49128 SWIGINTERN PyObject *_wrap_SizerFlags_Bottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49129 PyObject *resultobj = 0;
49130 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49131 wxSizerFlags *result = 0 ;
49132 void *argp1 = 0 ;
49133 int res1 = 0 ;
49134 PyObject *swig_obj[1] ;
49135
49136 if (!args) SWIG_fail;
49137 swig_obj[0] = args;
49138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49139 if (!SWIG_IsOK(res1)) {
49140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Bottom" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49141 }
49142 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49143 {
49144 PyThreadState* __tstate = wxPyBeginAllowThreads();
49145 {
49146 wxSizerFlags &_result_ref = (arg1)->Bottom();
49147 result = (wxSizerFlags *) &_result_ref;
49148 }
49149 wxPyEndAllowThreads(__tstate);
49150 if (PyErr_Occurred()) SWIG_fail;
49151 }
49152 {
49153 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49154 }
49155 return resultobj;
49156 fail:
49157 return NULL;
49158 }
49159
49160
49161 SWIGINTERN PyObject *_wrap_SizerFlags_Shaped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49162 PyObject *resultobj = 0;
49163 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49164 wxSizerFlags *result = 0 ;
49165 void *argp1 = 0 ;
49166 int res1 = 0 ;
49167 PyObject *swig_obj[1] ;
49168
49169 if (!args) SWIG_fail;
49170 swig_obj[0] = args;
49171 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49172 if (!SWIG_IsOK(res1)) {
49173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Shaped" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49174 }
49175 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49176 {
49177 PyThreadState* __tstate = wxPyBeginAllowThreads();
49178 {
49179 wxSizerFlags &_result_ref = (arg1)->Shaped();
49180 result = (wxSizerFlags *) &_result_ref;
49181 }
49182 wxPyEndAllowThreads(__tstate);
49183 if (PyErr_Occurred()) SWIG_fail;
49184 }
49185 {
49186 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49187 }
49188 return resultobj;
49189 fail:
49190 return NULL;
49191 }
49192
49193
49194 SWIGINTERN PyObject *_wrap_SizerFlags_FixedMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49195 PyObject *resultobj = 0;
49196 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49197 wxSizerFlags *result = 0 ;
49198 void *argp1 = 0 ;
49199 int res1 = 0 ;
49200 PyObject *swig_obj[1] ;
49201
49202 if (!args) SWIG_fail;
49203 swig_obj[0] = args;
49204 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49205 if (!SWIG_IsOK(res1)) {
49206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_FixedMinSize" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49207 }
49208 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49209 {
49210 PyThreadState* __tstate = wxPyBeginAllowThreads();
49211 {
49212 wxSizerFlags &_result_ref = (arg1)->FixedMinSize();
49213 result = (wxSizerFlags *) &_result_ref;
49214 }
49215 wxPyEndAllowThreads(__tstate);
49216 if (PyErr_Occurred()) SWIG_fail;
49217 }
49218 {
49219 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49220 }
49221 return resultobj;
49222 fail:
49223 return NULL;
49224 }
49225
49226
49227 SWIGINTERN PyObject *_wrap_SizerFlags_Border(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49228 PyObject *resultobj = 0;
49229 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49230 int arg2 = (int) wxALL ;
49231 int arg3 = (int) -1 ;
49232 wxSizerFlags *result = 0 ;
49233 void *argp1 = 0 ;
49234 int res1 = 0 ;
49235 int val2 ;
49236 int ecode2 = 0 ;
49237 int val3 ;
49238 int ecode3 = 0 ;
49239 PyObject * obj0 = 0 ;
49240 PyObject * obj1 = 0 ;
49241 PyObject * obj2 = 0 ;
49242 char * kwnames[] = {
49243 (char *) "self",(char *) "direction",(char *) "borderInPixels", NULL
49244 };
49245
49246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:SizerFlags_Border",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49248 if (!SWIG_IsOK(res1)) {
49249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Border" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49250 }
49251 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49252 if (obj1) {
49253 ecode2 = SWIG_AsVal_int(obj1, &val2);
49254 if (!SWIG_IsOK(ecode2)) {
49255 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerFlags_Border" "', expected argument " "2"" of type '" "int""'");
49256 }
49257 arg2 = static_cast< int >(val2);
49258 }
49259 if (obj2) {
49260 ecode3 = SWIG_AsVal_int(obj2, &val3);
49261 if (!SWIG_IsOK(ecode3)) {
49262 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerFlags_Border" "', expected argument " "3"" of type '" "int""'");
49263 }
49264 arg3 = static_cast< int >(val3);
49265 }
49266 {
49267 PyThreadState* __tstate = wxPyBeginAllowThreads();
49268 {
49269 wxSizerFlags &_result_ref = wxSizerFlags_Border(arg1,arg2,arg3);
49270 result = (wxSizerFlags *) &_result_ref;
49271 }
49272 wxPyEndAllowThreads(__tstate);
49273 if (PyErr_Occurred()) SWIG_fail;
49274 }
49275 {
49276 resultobj = obj0; Py_INCREF(resultobj);
49277 }
49278 return resultobj;
49279 fail:
49280 return NULL;
49281 }
49282
49283
49284 SWIGINTERN PyObject *_wrap_SizerFlags_DoubleBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49285 PyObject *resultobj = 0;
49286 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49287 int arg2 = (int) wxALL ;
49288 wxSizerFlags *result = 0 ;
49289 void *argp1 = 0 ;
49290 int res1 = 0 ;
49291 int val2 ;
49292 int ecode2 = 0 ;
49293 PyObject * obj0 = 0 ;
49294 PyObject * obj1 = 0 ;
49295 char * kwnames[] = {
49296 (char *) "self",(char *) "direction", NULL
49297 };
49298
49299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SizerFlags_DoubleBorder",kwnames,&obj0,&obj1)) SWIG_fail;
49300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49301 if (!SWIG_IsOK(res1)) {
49302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_DoubleBorder" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49303 }
49304 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49305 if (obj1) {
49306 ecode2 = SWIG_AsVal_int(obj1, &val2);
49307 if (!SWIG_IsOK(ecode2)) {
49308 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerFlags_DoubleBorder" "', expected argument " "2"" of type '" "int""'");
49309 }
49310 arg2 = static_cast< int >(val2);
49311 }
49312 {
49313 PyThreadState* __tstate = wxPyBeginAllowThreads();
49314 {
49315 wxSizerFlags &_result_ref = (arg1)->DoubleBorder(arg2);
49316 result = (wxSizerFlags *) &_result_ref;
49317 }
49318 wxPyEndAllowThreads(__tstate);
49319 if (PyErr_Occurred()) SWIG_fail;
49320 }
49321 {
49322 resultobj = obj0; Py_INCREF(resultobj);
49323 }
49324 return resultobj;
49325 fail:
49326 return NULL;
49327 }
49328
49329
49330 SWIGINTERN PyObject *_wrap_SizerFlags_TripleBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49331 PyObject *resultobj = 0;
49332 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49333 int arg2 = (int) wxALL ;
49334 wxSizerFlags *result = 0 ;
49335 void *argp1 = 0 ;
49336 int res1 = 0 ;
49337 int val2 ;
49338 int ecode2 = 0 ;
49339 PyObject * obj0 = 0 ;
49340 PyObject * obj1 = 0 ;
49341 char * kwnames[] = {
49342 (char *) "self",(char *) "direction", NULL
49343 };
49344
49345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SizerFlags_TripleBorder",kwnames,&obj0,&obj1)) SWIG_fail;
49346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49347 if (!SWIG_IsOK(res1)) {
49348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_TripleBorder" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49349 }
49350 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49351 if (obj1) {
49352 ecode2 = SWIG_AsVal_int(obj1, &val2);
49353 if (!SWIG_IsOK(ecode2)) {
49354 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerFlags_TripleBorder" "', expected argument " "2"" of type '" "int""'");
49355 }
49356 arg2 = static_cast< int >(val2);
49357 }
49358 {
49359 PyThreadState* __tstate = wxPyBeginAllowThreads();
49360 {
49361 wxSizerFlags &_result_ref = (arg1)->TripleBorder(arg2);
49362 result = (wxSizerFlags *) &_result_ref;
49363 }
49364 wxPyEndAllowThreads(__tstate);
49365 if (PyErr_Occurred()) SWIG_fail;
49366 }
49367 {
49368 resultobj = obj0; Py_INCREF(resultobj);
49369 }
49370 return resultobj;
49371 fail:
49372 return NULL;
49373 }
49374
49375
49376 SWIGINTERN PyObject *_wrap_SizerFlags_HorzBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49377 PyObject *resultobj = 0;
49378 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49379 wxSizerFlags *result = 0 ;
49380 void *argp1 = 0 ;
49381 int res1 = 0 ;
49382 PyObject *swig_obj[1] ;
49383
49384 if (!args) SWIG_fail;
49385 swig_obj[0] = args;
49386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49387 if (!SWIG_IsOK(res1)) {
49388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_HorzBorder" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49389 }
49390 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49391 {
49392 PyThreadState* __tstate = wxPyBeginAllowThreads();
49393 {
49394 wxSizerFlags &_result_ref = (arg1)->HorzBorder();
49395 result = (wxSizerFlags *) &_result_ref;
49396 }
49397 wxPyEndAllowThreads(__tstate);
49398 if (PyErr_Occurred()) SWIG_fail;
49399 }
49400 {
49401 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49402 }
49403 return resultobj;
49404 fail:
49405 return NULL;
49406 }
49407
49408
49409 SWIGINTERN PyObject *_wrap_SizerFlags_DoubleHorzBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49410 PyObject *resultobj = 0;
49411 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49412 wxSizerFlags *result = 0 ;
49413 void *argp1 = 0 ;
49414 int res1 = 0 ;
49415 PyObject *swig_obj[1] ;
49416
49417 if (!args) SWIG_fail;
49418 swig_obj[0] = args;
49419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49420 if (!SWIG_IsOK(res1)) {
49421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_DoubleHorzBorder" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49422 }
49423 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49424 {
49425 PyThreadState* __tstate = wxPyBeginAllowThreads();
49426 {
49427 wxSizerFlags &_result_ref = (arg1)->DoubleHorzBorder();
49428 result = (wxSizerFlags *) &_result_ref;
49429 }
49430 wxPyEndAllowThreads(__tstate);
49431 if (PyErr_Occurred()) SWIG_fail;
49432 }
49433 {
49434 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49435 }
49436 return resultobj;
49437 fail:
49438 return NULL;
49439 }
49440
49441
49442 SWIGINTERN PyObject *_wrap_SizerFlags_GetDefaultBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49443 PyObject *resultobj = 0;
49444 int result;
49445
49446 if (!SWIG_Python_UnpackTuple(args,"SizerFlags_GetDefaultBorder",0,0,0)) SWIG_fail;
49447 {
49448 PyThreadState* __tstate = wxPyBeginAllowThreads();
49449 result = (int)wxSizerFlags::GetDefaultBorder();
49450 wxPyEndAllowThreads(__tstate);
49451 if (PyErr_Occurred()) SWIG_fail;
49452 }
49453 resultobj = SWIG_From_int(static_cast< int >(result));
49454 return resultobj;
49455 fail:
49456 return NULL;
49457 }
49458
49459
49460 SWIGINTERN PyObject *_wrap_SizerFlags_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49461 PyObject *resultobj = 0;
49462 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49463 int result;
49464 void *argp1 = 0 ;
49465 int res1 = 0 ;
49466 PyObject *swig_obj[1] ;
49467
49468 if (!args) SWIG_fail;
49469 swig_obj[0] = args;
49470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49471 if (!SWIG_IsOK(res1)) {
49472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_GetProportion" "', expected argument " "1"" of type '" "wxSizerFlags const *""'");
49473 }
49474 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49475 {
49476 PyThreadState* __tstate = wxPyBeginAllowThreads();
49477 result = (int)((wxSizerFlags const *)arg1)->GetProportion();
49478 wxPyEndAllowThreads(__tstate);
49479 if (PyErr_Occurred()) SWIG_fail;
49480 }
49481 resultobj = SWIG_From_int(static_cast< int >(result));
49482 return resultobj;
49483 fail:
49484 return NULL;
49485 }
49486
49487
49488 SWIGINTERN PyObject *_wrap_SizerFlags_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49489 PyObject *resultobj = 0;
49490 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49491 int result;
49492 void *argp1 = 0 ;
49493 int res1 = 0 ;
49494 PyObject *swig_obj[1] ;
49495
49496 if (!args) SWIG_fail;
49497 swig_obj[0] = args;
49498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49499 if (!SWIG_IsOK(res1)) {
49500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_GetFlags" "', expected argument " "1"" of type '" "wxSizerFlags const *""'");
49501 }
49502 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49503 {
49504 PyThreadState* __tstate = wxPyBeginAllowThreads();
49505 result = (int)((wxSizerFlags const *)arg1)->GetFlags();
49506 wxPyEndAllowThreads(__tstate);
49507 if (PyErr_Occurred()) SWIG_fail;
49508 }
49509 resultobj = SWIG_From_int(static_cast< int >(result));
49510 return resultobj;
49511 fail:
49512 return NULL;
49513 }
49514
49515
49516 SWIGINTERN PyObject *_wrap_SizerFlags_GetBorderInPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49517 PyObject *resultobj = 0;
49518 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49519 int result;
49520 void *argp1 = 0 ;
49521 int res1 = 0 ;
49522 PyObject *swig_obj[1] ;
49523
49524 if (!args) SWIG_fail;
49525 swig_obj[0] = args;
49526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49527 if (!SWIG_IsOK(res1)) {
49528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_GetBorderInPixels" "', expected argument " "1"" of type '" "wxSizerFlags const *""'");
49529 }
49530 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49531 {
49532 PyThreadState* __tstate = wxPyBeginAllowThreads();
49533 result = (int)((wxSizerFlags const *)arg1)->GetBorderInPixels();
49534 wxPyEndAllowThreads(__tstate);
49535 if (PyErr_Occurred()) SWIG_fail;
49536 }
49537 resultobj = SWIG_From_int(static_cast< int >(result));
49538 return resultobj;
49539 fail:
49540 return NULL;
49541 }
49542
49543
49544 SWIGINTERN PyObject *SizerFlags_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49545 PyObject *obj;
49546 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49547 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerFlags, SWIG_NewClientData(obj));
49548 return SWIG_Py_Void();
49549 }
49550
49551 SWIGINTERN PyObject *SizerFlags_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49552 return SWIG_Python_InitShadowInstance(args);
49553 }
49554
49555 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49556 PyObject *resultobj = 0;
49557 wxSizerItem *result = 0 ;
49558
49559 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
49560 {
49561 PyThreadState* __tstate = wxPyBeginAllowThreads();
49562 result = (wxSizerItem *)new wxSizerItem();
49563 wxPyEndAllowThreads(__tstate);
49564 if (PyErr_Occurred()) SWIG_fail;
49565 }
49566 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
49567 return resultobj;
49568 fail:
49569 return NULL;
49570 }
49571
49572
49573 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49574 PyObject *resultobj = 0;
49575 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49576 void *argp1 = 0 ;
49577 int res1 = 0 ;
49578 PyObject *swig_obj[1] ;
49579
49580 if (!args) SWIG_fail;
49581 swig_obj[0] = args;
49582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
49583 if (!SWIG_IsOK(res1)) {
49584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49585 }
49586 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49587 {
49588 PyThreadState* __tstate = wxPyBeginAllowThreads();
49589 delete arg1;
49590
49591 wxPyEndAllowThreads(__tstate);
49592 if (PyErr_Occurred()) SWIG_fail;
49593 }
49594 resultobj = SWIG_Py_Void();
49595 return resultobj;
49596 fail:
49597 return NULL;
49598 }
49599
49600
49601 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49602 PyObject *resultobj = 0;
49603 wxWindow *arg1 = (wxWindow *) 0 ;
49604 int arg2 ;
49605 int arg3 ;
49606 int arg4 ;
49607 PyObject *arg5 = (PyObject *) NULL ;
49608 wxSizerItem *result = 0 ;
49609 void *argp1 = 0 ;
49610 int res1 = 0 ;
49611 int val2 ;
49612 int ecode2 = 0 ;
49613 int val3 ;
49614 int ecode3 = 0 ;
49615 int val4 ;
49616 int ecode4 = 0 ;
49617 PyObject * obj0 = 0 ;
49618 PyObject * obj1 = 0 ;
49619 PyObject * obj2 = 0 ;
49620 PyObject * obj3 = 0 ;
49621 PyObject * obj4 = 0 ;
49622 char * kwnames[] = {
49623 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49624 };
49625
49626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
49627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
49628 if (!SWIG_IsOK(res1)) {
49629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
49630 }
49631 arg1 = reinterpret_cast< wxWindow * >(argp1);
49632 ecode2 = SWIG_AsVal_int(obj1, &val2);
49633 if (!SWIG_IsOK(ecode2)) {
49634 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
49635 }
49636 arg2 = static_cast< int >(val2);
49637 ecode3 = SWIG_AsVal_int(obj2, &val3);
49638 if (!SWIG_IsOK(ecode3)) {
49639 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
49640 }
49641 arg3 = static_cast< int >(val3);
49642 ecode4 = SWIG_AsVal_int(obj3, &val4);
49643 if (!SWIG_IsOK(ecode4)) {
49644 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
49645 }
49646 arg4 = static_cast< int >(val4);
49647 if (obj4) {
49648 arg5 = obj4;
49649 }
49650 {
49651 PyThreadState* __tstate = wxPyBeginAllowThreads();
49652 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
49653 wxPyEndAllowThreads(__tstate);
49654 if (PyErr_Occurred()) SWIG_fail;
49655 }
49656 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
49657 return resultobj;
49658 fail:
49659 return NULL;
49660 }
49661
49662
49663 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49664 PyObject *resultobj = 0;
49665 int arg1 ;
49666 int arg2 ;
49667 int arg3 ;
49668 int arg4 ;
49669 int arg5 ;
49670 PyObject *arg6 = (PyObject *) NULL ;
49671 wxSizerItem *result = 0 ;
49672 int val1 ;
49673 int ecode1 = 0 ;
49674 int val2 ;
49675 int ecode2 = 0 ;
49676 int val3 ;
49677 int ecode3 = 0 ;
49678 int val4 ;
49679 int ecode4 = 0 ;
49680 int val5 ;
49681 int ecode5 = 0 ;
49682 PyObject * obj0 = 0 ;
49683 PyObject * obj1 = 0 ;
49684 PyObject * obj2 = 0 ;
49685 PyObject * obj3 = 0 ;
49686 PyObject * obj4 = 0 ;
49687 PyObject * obj5 = 0 ;
49688 char * kwnames[] = {
49689 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49690 };
49691
49692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49693 ecode1 = SWIG_AsVal_int(obj0, &val1);
49694 if (!SWIG_IsOK(ecode1)) {
49695 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
49696 }
49697 arg1 = static_cast< int >(val1);
49698 ecode2 = SWIG_AsVal_int(obj1, &val2);
49699 if (!SWIG_IsOK(ecode2)) {
49700 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
49701 }
49702 arg2 = static_cast< int >(val2);
49703 ecode3 = SWIG_AsVal_int(obj2, &val3);
49704 if (!SWIG_IsOK(ecode3)) {
49705 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
49706 }
49707 arg3 = static_cast< int >(val3);
49708 ecode4 = SWIG_AsVal_int(obj3, &val4);
49709 if (!SWIG_IsOK(ecode4)) {
49710 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
49711 }
49712 arg4 = static_cast< int >(val4);
49713 ecode5 = SWIG_AsVal_int(obj4, &val5);
49714 if (!SWIG_IsOK(ecode5)) {
49715 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
49716 }
49717 arg5 = static_cast< int >(val5);
49718 if (obj5) {
49719 arg6 = obj5;
49720 }
49721 {
49722 PyThreadState* __tstate = wxPyBeginAllowThreads();
49723 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
49724 wxPyEndAllowThreads(__tstate);
49725 if (PyErr_Occurred()) SWIG_fail;
49726 }
49727 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
49728 return resultobj;
49729 fail:
49730 return NULL;
49731 }
49732
49733
49734 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49735 PyObject *resultobj = 0;
49736 wxSizer *arg1 = (wxSizer *) 0 ;
49737 int arg2 ;
49738 int arg3 ;
49739 int arg4 ;
49740 PyObject *arg5 = (PyObject *) NULL ;
49741 wxSizerItem *result = 0 ;
49742 int res1 = 0 ;
49743 int val2 ;
49744 int ecode2 = 0 ;
49745 int val3 ;
49746 int ecode3 = 0 ;
49747 int val4 ;
49748 int ecode4 = 0 ;
49749 PyObject * obj0 = 0 ;
49750 PyObject * obj1 = 0 ;
49751 PyObject * obj2 = 0 ;
49752 PyObject * obj3 = 0 ;
49753 PyObject * obj4 = 0 ;
49754 char * kwnames[] = {
49755 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49756 };
49757
49758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
49759 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49760 if (!SWIG_IsOK(res1)) {
49761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49762 }
49763 ecode2 = SWIG_AsVal_int(obj1, &val2);
49764 if (!SWIG_IsOK(ecode2)) {
49765 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
49766 }
49767 arg2 = static_cast< int >(val2);
49768 ecode3 = SWIG_AsVal_int(obj2, &val3);
49769 if (!SWIG_IsOK(ecode3)) {
49770 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
49771 }
49772 arg3 = static_cast< int >(val3);
49773 ecode4 = SWIG_AsVal_int(obj3, &val4);
49774 if (!SWIG_IsOK(ecode4)) {
49775 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
49776 }
49777 arg4 = static_cast< int >(val4);
49778 if (obj4) {
49779 arg5 = obj4;
49780 }
49781 {
49782 PyThreadState* __tstate = wxPyBeginAllowThreads();
49783 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
49784 wxPyEndAllowThreads(__tstate);
49785 if (PyErr_Occurred()) SWIG_fail;
49786 }
49787 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
49788 return resultobj;
49789 fail:
49790 return NULL;
49791 }
49792
49793
49794 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49795 PyObject *resultobj = 0;
49796 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49797 void *argp1 = 0 ;
49798 int res1 = 0 ;
49799 PyObject *swig_obj[1] ;
49800
49801 if (!args) SWIG_fail;
49802 swig_obj[0] = args;
49803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49804 if (!SWIG_IsOK(res1)) {
49805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49806 }
49807 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49808 {
49809 PyThreadState* __tstate = wxPyBeginAllowThreads();
49810 (arg1)->DeleteWindows();
49811 wxPyEndAllowThreads(__tstate);
49812 if (PyErr_Occurred()) SWIG_fail;
49813 }
49814 resultobj = SWIG_Py_Void();
49815 return resultobj;
49816 fail:
49817 return NULL;
49818 }
49819
49820
49821 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49822 PyObject *resultobj = 0;
49823 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49824 void *argp1 = 0 ;
49825 int res1 = 0 ;
49826 PyObject *swig_obj[1] ;
49827
49828 if (!args) SWIG_fail;
49829 swig_obj[0] = args;
49830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49831 if (!SWIG_IsOK(res1)) {
49832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49833 }
49834 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49835 {
49836 PyThreadState* __tstate = wxPyBeginAllowThreads();
49837 (arg1)->DetachSizer();
49838 wxPyEndAllowThreads(__tstate);
49839 if (PyErr_Occurred()) SWIG_fail;
49840 }
49841 resultobj = SWIG_Py_Void();
49842 return resultobj;
49843 fail:
49844 return NULL;
49845 }
49846
49847
49848 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49849 PyObject *resultobj = 0;
49850 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49851 wxSize result;
49852 void *argp1 = 0 ;
49853 int res1 = 0 ;
49854 PyObject *swig_obj[1] ;
49855
49856 if (!args) SWIG_fail;
49857 swig_obj[0] = args;
49858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49859 if (!SWIG_IsOK(res1)) {
49860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49861 }
49862 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49863 {
49864 PyThreadState* __tstate = wxPyBeginAllowThreads();
49865 result = (arg1)->GetSize();
49866 wxPyEndAllowThreads(__tstate);
49867 if (PyErr_Occurred()) SWIG_fail;
49868 }
49869 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
49870 return resultobj;
49871 fail:
49872 return NULL;
49873 }
49874
49875
49876 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49877 PyObject *resultobj = 0;
49878 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49879 wxSize result;
49880 void *argp1 = 0 ;
49881 int res1 = 0 ;
49882 PyObject *swig_obj[1] ;
49883
49884 if (!args) SWIG_fail;
49885 swig_obj[0] = args;
49886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49887 if (!SWIG_IsOK(res1)) {
49888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49889 }
49890 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49891 {
49892 PyThreadState* __tstate = wxPyBeginAllowThreads();
49893 result = (arg1)->CalcMin();
49894 wxPyEndAllowThreads(__tstate);
49895 if (PyErr_Occurred()) SWIG_fail;
49896 }
49897 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
49898 return resultobj;
49899 fail:
49900 return NULL;
49901 }
49902
49903
49904 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49905 PyObject *resultobj = 0;
49906 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49907 wxPoint *arg2 = 0 ;
49908 wxSize *arg3 = 0 ;
49909 void *argp1 = 0 ;
49910 int res1 = 0 ;
49911 wxPoint temp2 ;
49912 wxSize temp3 ;
49913 PyObject * obj0 = 0 ;
49914 PyObject * obj1 = 0 ;
49915 PyObject * obj2 = 0 ;
49916 char * kwnames[] = {
49917 (char *) "self",(char *) "pos",(char *) "size", NULL
49918 };
49919
49920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49922 if (!SWIG_IsOK(res1)) {
49923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49924 }
49925 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49926 {
49927 arg2 = &temp2;
49928 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
49929 }
49930 {
49931 arg3 = &temp3;
49932 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
49933 }
49934 {
49935 PyThreadState* __tstate = wxPyBeginAllowThreads();
49936 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
49937 wxPyEndAllowThreads(__tstate);
49938 if (PyErr_Occurred()) SWIG_fail;
49939 }
49940 resultobj = SWIG_Py_Void();
49941 return resultobj;
49942 fail:
49943 return NULL;
49944 }
49945
49946
49947 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49948 PyObject *resultobj = 0;
49949 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49950 wxSize result;
49951 void *argp1 = 0 ;
49952 int res1 = 0 ;
49953 PyObject *swig_obj[1] ;
49954
49955 if (!args) SWIG_fail;
49956 swig_obj[0] = args;
49957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49958 if (!SWIG_IsOK(res1)) {
49959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49960 }
49961 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49962 {
49963 PyThreadState* __tstate = wxPyBeginAllowThreads();
49964 result = (arg1)->GetMinSize();
49965 wxPyEndAllowThreads(__tstate);
49966 if (PyErr_Occurred()) SWIG_fail;
49967 }
49968 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
49969 return resultobj;
49970 fail:
49971 return NULL;
49972 }
49973
49974
49975 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49976 PyObject *resultobj = 0;
49977 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49978 wxSize result;
49979 void *argp1 = 0 ;
49980 int res1 = 0 ;
49981 PyObject *swig_obj[1] ;
49982
49983 if (!args) SWIG_fail;
49984 swig_obj[0] = args;
49985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49986 if (!SWIG_IsOK(res1)) {
49987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
49988 }
49989 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49990 {
49991 PyThreadState* __tstate = wxPyBeginAllowThreads();
49992 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
49993 wxPyEndAllowThreads(__tstate);
49994 if (PyErr_Occurred()) SWIG_fail;
49995 }
49996 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
49997 return resultobj;
49998 fail:
49999 return NULL;
50000 }
50001
50002
50003 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50004 PyObject *resultobj = 0;
50005 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50006 int arg2 ;
50007 int arg3 ;
50008 void *argp1 = 0 ;
50009 int res1 = 0 ;
50010 int val2 ;
50011 int ecode2 = 0 ;
50012 int val3 ;
50013 int ecode3 = 0 ;
50014 PyObject * obj0 = 0 ;
50015 PyObject * obj1 = 0 ;
50016 PyObject * obj2 = 0 ;
50017 char * kwnames[] = {
50018 (char *) "self",(char *) "x",(char *) "y", NULL
50019 };
50020
50021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50023 if (!SWIG_IsOK(res1)) {
50024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50025 }
50026 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50027 ecode2 = SWIG_AsVal_int(obj1, &val2);
50028 if (!SWIG_IsOK(ecode2)) {
50029 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
50030 }
50031 arg2 = static_cast< int >(val2);
50032 ecode3 = SWIG_AsVal_int(obj2, &val3);
50033 if (!SWIG_IsOK(ecode3)) {
50034 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
50035 }
50036 arg3 = static_cast< int >(val3);
50037 {
50038 PyThreadState* __tstate = wxPyBeginAllowThreads();
50039 (arg1)->SetInitSize(arg2,arg3);
50040 wxPyEndAllowThreads(__tstate);
50041 if (PyErr_Occurred()) SWIG_fail;
50042 }
50043 resultobj = SWIG_Py_Void();
50044 return resultobj;
50045 fail:
50046 return NULL;
50047 }
50048
50049
50050 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50051 PyObject *resultobj = 0;
50052 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50053 int arg2 ;
50054 int arg3 ;
50055 void *argp1 = 0 ;
50056 int res1 = 0 ;
50057 int val2 ;
50058 int ecode2 = 0 ;
50059 int val3 ;
50060 int ecode3 = 0 ;
50061 PyObject * obj0 = 0 ;
50062 PyObject * obj1 = 0 ;
50063 PyObject * obj2 = 0 ;
50064 char * kwnames[] = {
50065 (char *) "self",(char *) "width",(char *) "height", NULL
50066 };
50067
50068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50070 if (!SWIG_IsOK(res1)) {
50071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50072 }
50073 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50074 ecode2 = SWIG_AsVal_int(obj1, &val2);
50075 if (!SWIG_IsOK(ecode2)) {
50076 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
50077 }
50078 arg2 = static_cast< int >(val2);
50079 ecode3 = SWIG_AsVal_int(obj2, &val3);
50080 if (!SWIG_IsOK(ecode3)) {
50081 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
50082 }
50083 arg3 = static_cast< int >(val3);
50084 {
50085 PyThreadState* __tstate = wxPyBeginAllowThreads();
50086 (arg1)->SetRatio(arg2,arg3);
50087 wxPyEndAllowThreads(__tstate);
50088 if (PyErr_Occurred()) SWIG_fail;
50089 }
50090 resultobj = SWIG_Py_Void();
50091 return resultobj;
50092 fail:
50093 return NULL;
50094 }
50095
50096
50097 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50098 PyObject *resultobj = 0;
50099 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50100 wxSize *arg2 = 0 ;
50101 void *argp1 = 0 ;
50102 int res1 = 0 ;
50103 wxSize temp2 ;
50104 PyObject * obj0 = 0 ;
50105 PyObject * obj1 = 0 ;
50106 char * kwnames[] = {
50107 (char *) "self",(char *) "size", NULL
50108 };
50109
50110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
50111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50112 if (!SWIG_IsOK(res1)) {
50113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50114 }
50115 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50116 {
50117 arg2 = &temp2;
50118 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50119 }
50120 {
50121 PyThreadState* __tstate = wxPyBeginAllowThreads();
50122 (arg1)->SetRatio((wxSize const &)*arg2);
50123 wxPyEndAllowThreads(__tstate);
50124 if (PyErr_Occurred()) SWIG_fail;
50125 }
50126 resultobj = SWIG_Py_Void();
50127 return resultobj;
50128 fail:
50129 return NULL;
50130 }
50131
50132
50133 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50134 PyObject *resultobj = 0;
50135 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50136 float arg2 ;
50137 void *argp1 = 0 ;
50138 int res1 = 0 ;
50139 float val2 ;
50140 int ecode2 = 0 ;
50141 PyObject * obj0 = 0 ;
50142 PyObject * obj1 = 0 ;
50143 char * kwnames[] = {
50144 (char *) "self",(char *) "ratio", NULL
50145 };
50146
50147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
50148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50149 if (!SWIG_IsOK(res1)) {
50150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50151 }
50152 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50153 ecode2 = SWIG_AsVal_float(obj1, &val2);
50154 if (!SWIG_IsOK(ecode2)) {
50155 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
50156 }
50157 arg2 = static_cast< float >(val2);
50158 {
50159 PyThreadState* __tstate = wxPyBeginAllowThreads();
50160 (arg1)->SetRatio(arg2);
50161 wxPyEndAllowThreads(__tstate);
50162 if (PyErr_Occurred()) SWIG_fail;
50163 }
50164 resultobj = SWIG_Py_Void();
50165 return resultobj;
50166 fail:
50167 return NULL;
50168 }
50169
50170
50171 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50172 PyObject *resultobj = 0;
50173 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50174 float result;
50175 void *argp1 = 0 ;
50176 int res1 = 0 ;
50177 PyObject *swig_obj[1] ;
50178
50179 if (!args) SWIG_fail;
50180 swig_obj[0] = args;
50181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50182 if (!SWIG_IsOK(res1)) {
50183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50184 }
50185 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50186 {
50187 PyThreadState* __tstate = wxPyBeginAllowThreads();
50188 result = (float)(arg1)->GetRatio();
50189 wxPyEndAllowThreads(__tstate);
50190 if (PyErr_Occurred()) SWIG_fail;
50191 }
50192 resultobj = SWIG_From_float(static_cast< float >(result));
50193 return resultobj;
50194 fail:
50195 return NULL;
50196 }
50197
50198
50199 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50200 PyObject *resultobj = 0;
50201 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50202 wxRect result;
50203 void *argp1 = 0 ;
50204 int res1 = 0 ;
50205 PyObject *swig_obj[1] ;
50206
50207 if (!args) SWIG_fail;
50208 swig_obj[0] = args;
50209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50210 if (!SWIG_IsOK(res1)) {
50211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50212 }
50213 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50214 {
50215 PyThreadState* __tstate = wxPyBeginAllowThreads();
50216 result = (arg1)->GetRect();
50217 wxPyEndAllowThreads(__tstate);
50218 if (PyErr_Occurred()) SWIG_fail;
50219 }
50220 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
50221 return resultobj;
50222 fail:
50223 return NULL;
50224 }
50225
50226
50227 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50228 PyObject *resultobj = 0;
50229 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50230 bool result;
50231 void *argp1 = 0 ;
50232 int res1 = 0 ;
50233 PyObject *swig_obj[1] ;
50234
50235 if (!args) SWIG_fail;
50236 swig_obj[0] = args;
50237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50238 if (!SWIG_IsOK(res1)) {
50239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50240 }
50241 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50242 {
50243 PyThreadState* __tstate = wxPyBeginAllowThreads();
50244 result = (bool)(arg1)->IsWindow();
50245 wxPyEndAllowThreads(__tstate);
50246 if (PyErr_Occurred()) SWIG_fail;
50247 }
50248 {
50249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50250 }
50251 return resultobj;
50252 fail:
50253 return NULL;
50254 }
50255
50256
50257 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50258 PyObject *resultobj = 0;
50259 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50260 bool result;
50261 void *argp1 = 0 ;
50262 int res1 = 0 ;
50263 PyObject *swig_obj[1] ;
50264
50265 if (!args) SWIG_fail;
50266 swig_obj[0] = args;
50267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50268 if (!SWIG_IsOK(res1)) {
50269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50270 }
50271 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50272 {
50273 PyThreadState* __tstate = wxPyBeginAllowThreads();
50274 result = (bool)(arg1)->IsSizer();
50275 wxPyEndAllowThreads(__tstate);
50276 if (PyErr_Occurred()) SWIG_fail;
50277 }
50278 {
50279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50280 }
50281 return resultobj;
50282 fail:
50283 return NULL;
50284 }
50285
50286
50287 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50288 PyObject *resultobj = 0;
50289 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50290 bool result;
50291 void *argp1 = 0 ;
50292 int res1 = 0 ;
50293 PyObject *swig_obj[1] ;
50294
50295 if (!args) SWIG_fail;
50296 swig_obj[0] = args;
50297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50298 if (!SWIG_IsOK(res1)) {
50299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50300 }
50301 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50302 {
50303 PyThreadState* __tstate = wxPyBeginAllowThreads();
50304 result = (bool)(arg1)->IsSpacer();
50305 wxPyEndAllowThreads(__tstate);
50306 if (PyErr_Occurred()) SWIG_fail;
50307 }
50308 {
50309 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50310 }
50311 return resultobj;
50312 fail:
50313 return NULL;
50314 }
50315
50316
50317 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50318 PyObject *resultobj = 0;
50319 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50320 int arg2 ;
50321 void *argp1 = 0 ;
50322 int res1 = 0 ;
50323 int val2 ;
50324 int ecode2 = 0 ;
50325 PyObject * obj0 = 0 ;
50326 PyObject * obj1 = 0 ;
50327 char * kwnames[] = {
50328 (char *) "self",(char *) "proportion", NULL
50329 };
50330
50331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
50332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50333 if (!SWIG_IsOK(res1)) {
50334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50335 }
50336 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50337 ecode2 = SWIG_AsVal_int(obj1, &val2);
50338 if (!SWIG_IsOK(ecode2)) {
50339 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
50340 }
50341 arg2 = static_cast< int >(val2);
50342 {
50343 PyThreadState* __tstate = wxPyBeginAllowThreads();
50344 (arg1)->SetProportion(arg2);
50345 wxPyEndAllowThreads(__tstate);
50346 if (PyErr_Occurred()) SWIG_fail;
50347 }
50348 resultobj = SWIG_Py_Void();
50349 return resultobj;
50350 fail:
50351 return NULL;
50352 }
50353
50354
50355 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50356 PyObject *resultobj = 0;
50357 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50358 int result;
50359 void *argp1 = 0 ;
50360 int res1 = 0 ;
50361 PyObject *swig_obj[1] ;
50362
50363 if (!args) SWIG_fail;
50364 swig_obj[0] = args;
50365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50366 if (!SWIG_IsOK(res1)) {
50367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50368 }
50369 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50370 {
50371 PyThreadState* __tstate = wxPyBeginAllowThreads();
50372 result = (int)(arg1)->GetProportion();
50373 wxPyEndAllowThreads(__tstate);
50374 if (PyErr_Occurred()) SWIG_fail;
50375 }
50376 resultobj = SWIG_From_int(static_cast< int >(result));
50377 return resultobj;
50378 fail:
50379 return NULL;
50380 }
50381
50382
50383 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50384 PyObject *resultobj = 0;
50385 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50386 int arg2 ;
50387 void *argp1 = 0 ;
50388 int res1 = 0 ;
50389 int val2 ;
50390 int ecode2 = 0 ;
50391 PyObject * obj0 = 0 ;
50392 PyObject * obj1 = 0 ;
50393 char * kwnames[] = {
50394 (char *) "self",(char *) "flag", NULL
50395 };
50396
50397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
50398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50399 if (!SWIG_IsOK(res1)) {
50400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50401 }
50402 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50403 ecode2 = SWIG_AsVal_int(obj1, &val2);
50404 if (!SWIG_IsOK(ecode2)) {
50405 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
50406 }
50407 arg2 = static_cast< int >(val2);
50408 {
50409 PyThreadState* __tstate = wxPyBeginAllowThreads();
50410 (arg1)->SetFlag(arg2);
50411 wxPyEndAllowThreads(__tstate);
50412 if (PyErr_Occurred()) SWIG_fail;
50413 }
50414 resultobj = SWIG_Py_Void();
50415 return resultobj;
50416 fail:
50417 return NULL;
50418 }
50419
50420
50421 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50422 PyObject *resultobj = 0;
50423 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50424 int result;
50425 void *argp1 = 0 ;
50426 int res1 = 0 ;
50427 PyObject *swig_obj[1] ;
50428
50429 if (!args) SWIG_fail;
50430 swig_obj[0] = args;
50431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50432 if (!SWIG_IsOK(res1)) {
50433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50434 }
50435 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50436 {
50437 PyThreadState* __tstate = wxPyBeginAllowThreads();
50438 result = (int)(arg1)->GetFlag();
50439 wxPyEndAllowThreads(__tstate);
50440 if (PyErr_Occurred()) SWIG_fail;
50441 }
50442 resultobj = SWIG_From_int(static_cast< int >(result));
50443 return resultobj;
50444 fail:
50445 return NULL;
50446 }
50447
50448
50449 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50450 PyObject *resultobj = 0;
50451 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50452 int arg2 ;
50453 void *argp1 = 0 ;
50454 int res1 = 0 ;
50455 int val2 ;
50456 int ecode2 = 0 ;
50457 PyObject * obj0 = 0 ;
50458 PyObject * obj1 = 0 ;
50459 char * kwnames[] = {
50460 (char *) "self",(char *) "border", NULL
50461 };
50462
50463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
50464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50465 if (!SWIG_IsOK(res1)) {
50466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50467 }
50468 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50469 ecode2 = SWIG_AsVal_int(obj1, &val2);
50470 if (!SWIG_IsOK(ecode2)) {
50471 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
50472 }
50473 arg2 = static_cast< int >(val2);
50474 {
50475 PyThreadState* __tstate = wxPyBeginAllowThreads();
50476 (arg1)->SetBorder(arg2);
50477 wxPyEndAllowThreads(__tstate);
50478 if (PyErr_Occurred()) SWIG_fail;
50479 }
50480 resultobj = SWIG_Py_Void();
50481 return resultobj;
50482 fail:
50483 return NULL;
50484 }
50485
50486
50487 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50488 PyObject *resultobj = 0;
50489 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50490 int result;
50491 void *argp1 = 0 ;
50492 int res1 = 0 ;
50493 PyObject *swig_obj[1] ;
50494
50495 if (!args) SWIG_fail;
50496 swig_obj[0] = args;
50497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50498 if (!SWIG_IsOK(res1)) {
50499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50500 }
50501 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50502 {
50503 PyThreadState* __tstate = wxPyBeginAllowThreads();
50504 result = (int)(arg1)->GetBorder();
50505 wxPyEndAllowThreads(__tstate);
50506 if (PyErr_Occurred()) SWIG_fail;
50507 }
50508 resultobj = SWIG_From_int(static_cast< int >(result));
50509 return resultobj;
50510 fail:
50511 return NULL;
50512 }
50513
50514
50515 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50516 PyObject *resultobj = 0;
50517 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50518 wxWindow *result = 0 ;
50519 void *argp1 = 0 ;
50520 int res1 = 0 ;
50521 PyObject *swig_obj[1] ;
50522
50523 if (!args) SWIG_fail;
50524 swig_obj[0] = args;
50525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50526 if (!SWIG_IsOK(res1)) {
50527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50528 }
50529 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50530 {
50531 PyThreadState* __tstate = wxPyBeginAllowThreads();
50532 result = (wxWindow *)(arg1)->GetWindow();
50533 wxPyEndAllowThreads(__tstate);
50534 if (PyErr_Occurred()) SWIG_fail;
50535 }
50536 {
50537 resultobj = wxPyMake_wxObject(result, 0);
50538 }
50539 return resultobj;
50540 fail:
50541 return NULL;
50542 }
50543
50544
50545 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50546 PyObject *resultobj = 0;
50547 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50548 wxSizer *result = 0 ;
50549 void *argp1 = 0 ;
50550 int res1 = 0 ;
50551 PyObject *swig_obj[1] ;
50552
50553 if (!args) SWIG_fail;
50554 swig_obj[0] = args;
50555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50556 if (!SWIG_IsOK(res1)) {
50557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50558 }
50559 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50560 {
50561 PyThreadState* __tstate = wxPyBeginAllowThreads();
50562 result = (wxSizer *)(arg1)->GetSizer();
50563 wxPyEndAllowThreads(__tstate);
50564 if (PyErr_Occurred()) SWIG_fail;
50565 }
50566 {
50567 resultobj = wxPyMake_wxObject(result, (bool)0);
50568 }
50569 return resultobj;
50570 fail:
50571 return NULL;
50572 }
50573
50574
50575 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50576 PyObject *resultobj = 0;
50577 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50578 wxSize result;
50579 void *argp1 = 0 ;
50580 int res1 = 0 ;
50581 PyObject *swig_obj[1] ;
50582
50583 if (!args) SWIG_fail;
50584 swig_obj[0] = args;
50585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50586 if (!SWIG_IsOK(res1)) {
50587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50588 }
50589 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50590 {
50591 PyThreadState* __tstate = wxPyBeginAllowThreads();
50592 result = (arg1)->GetSpacer();
50593 wxPyEndAllowThreads(__tstate);
50594 if (PyErr_Occurred()) SWIG_fail;
50595 }
50596 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50597 return resultobj;
50598 fail:
50599 return NULL;
50600 }
50601
50602
50603 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50604 PyObject *resultobj = 0;
50605 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50606 wxWindow *arg2 = (wxWindow *) 0 ;
50607 void *argp1 = 0 ;
50608 int res1 = 0 ;
50609 void *argp2 = 0 ;
50610 int res2 = 0 ;
50611 PyObject * obj0 = 0 ;
50612 PyObject * obj1 = 0 ;
50613 char * kwnames[] = {
50614 (char *) "self",(char *) "window", NULL
50615 };
50616
50617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
50618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50619 if (!SWIG_IsOK(res1)) {
50620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50621 }
50622 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50623 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50624 if (!SWIG_IsOK(res2)) {
50625 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
50626 }
50627 arg2 = reinterpret_cast< wxWindow * >(argp2);
50628 {
50629 PyThreadState* __tstate = wxPyBeginAllowThreads();
50630 (arg1)->SetWindow(arg2);
50631 wxPyEndAllowThreads(__tstate);
50632 if (PyErr_Occurred()) SWIG_fail;
50633 }
50634 resultobj = SWIG_Py_Void();
50635 return resultobj;
50636 fail:
50637 return NULL;
50638 }
50639
50640
50641 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50642 PyObject *resultobj = 0;
50643 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50644 wxSizer *arg2 = (wxSizer *) 0 ;
50645 void *argp1 = 0 ;
50646 int res1 = 0 ;
50647 int res2 = 0 ;
50648 PyObject * obj0 = 0 ;
50649 PyObject * obj1 = 0 ;
50650 char * kwnames[] = {
50651 (char *) "self",(char *) "sizer", NULL
50652 };
50653
50654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50656 if (!SWIG_IsOK(res1)) {
50657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50658 }
50659 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50660 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
50661 if (!SWIG_IsOK(res2)) {
50662 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
50663 }
50664 {
50665 PyThreadState* __tstate = wxPyBeginAllowThreads();
50666 (arg1)->SetSizer(arg2);
50667 wxPyEndAllowThreads(__tstate);
50668 if (PyErr_Occurred()) SWIG_fail;
50669 }
50670 resultobj = SWIG_Py_Void();
50671 return resultobj;
50672 fail:
50673 return NULL;
50674 }
50675
50676
50677 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50678 PyObject *resultobj = 0;
50679 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50680 wxSize *arg2 = 0 ;
50681 void *argp1 = 0 ;
50682 int res1 = 0 ;
50683 wxSize temp2 ;
50684 PyObject * obj0 = 0 ;
50685 PyObject * obj1 = 0 ;
50686 char * kwnames[] = {
50687 (char *) "self",(char *) "size", NULL
50688 };
50689
50690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
50691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50692 if (!SWIG_IsOK(res1)) {
50693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50694 }
50695 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50696 {
50697 arg2 = &temp2;
50698 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50699 }
50700 {
50701 PyThreadState* __tstate = wxPyBeginAllowThreads();
50702 (arg1)->SetSpacer((wxSize const &)*arg2);
50703 wxPyEndAllowThreads(__tstate);
50704 if (PyErr_Occurred()) SWIG_fail;
50705 }
50706 resultobj = SWIG_Py_Void();
50707 return resultobj;
50708 fail:
50709 return NULL;
50710 }
50711
50712
50713 SWIGINTERN PyObject *_wrap_SizerItem_AssignWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50714 PyObject *resultobj = 0;
50715 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50716 wxWindow *arg2 = (wxWindow *) 0 ;
50717 void *argp1 = 0 ;
50718 int res1 = 0 ;
50719 void *argp2 = 0 ;
50720 int res2 = 0 ;
50721 PyObject * obj0 = 0 ;
50722 PyObject * obj1 = 0 ;
50723 char * kwnames[] = {
50724 (char *) "self",(char *) "window", NULL
50725 };
50726
50727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_AssignWindow",kwnames,&obj0,&obj1)) SWIG_fail;
50728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50729 if (!SWIG_IsOK(res1)) {
50730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_AssignWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50731 }
50732 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50733 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50734 if (!SWIG_IsOK(res2)) {
50735 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_AssignWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
50736 }
50737 arg2 = reinterpret_cast< wxWindow * >(argp2);
50738 {
50739 PyThreadState* __tstate = wxPyBeginAllowThreads();
50740 (arg1)->AssignWindow(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_SizerItem_AssignSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50752 PyObject *resultobj = 0;
50753 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50754 wxSizer *arg2 = (wxSizer *) 0 ;
50755 void *argp1 = 0 ;
50756 int res1 = 0 ;
50757 void *argp2 = 0 ;
50758 int res2 = 0 ;
50759 PyObject * obj0 = 0 ;
50760 PyObject * obj1 = 0 ;
50761 char * kwnames[] = {
50762 (char *) "self",(char *) "sizer", NULL
50763 };
50764
50765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_AssignSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50767 if (!SWIG_IsOK(res1)) {
50768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_AssignSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50769 }
50770 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50771 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50772 if (!SWIG_IsOK(res2)) {
50773 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_AssignSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
50774 }
50775 arg2 = reinterpret_cast< wxSizer * >(argp2);
50776 {
50777 PyThreadState* __tstate = wxPyBeginAllowThreads();
50778 (arg1)->AssignSizer(arg2);
50779 wxPyEndAllowThreads(__tstate);
50780 if (PyErr_Occurred()) SWIG_fail;
50781 }
50782 resultobj = SWIG_Py_Void();
50783 return resultobj;
50784 fail:
50785 return NULL;
50786 }
50787
50788
50789 SWIGINTERN PyObject *_wrap_SizerItem_AssignSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50790 PyObject *resultobj = 0;
50791 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50792 wxSize *arg2 = 0 ;
50793 void *argp1 = 0 ;
50794 int res1 = 0 ;
50795 wxSize temp2 ;
50796 PyObject * obj0 = 0 ;
50797 PyObject * obj1 = 0 ;
50798 char * kwnames[] = {
50799 (char *) "self",(char *) "size", NULL
50800 };
50801
50802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_AssignSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
50803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50804 if (!SWIG_IsOK(res1)) {
50805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_AssignSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50806 }
50807 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50808 {
50809 arg2 = &temp2;
50810 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50811 }
50812 {
50813 PyThreadState* __tstate = wxPyBeginAllowThreads();
50814 (arg1)->AssignSpacer((wxSize const &)*arg2);
50815 wxPyEndAllowThreads(__tstate);
50816 if (PyErr_Occurred()) SWIG_fail;
50817 }
50818 resultobj = SWIG_Py_Void();
50819 return resultobj;
50820 fail:
50821 return NULL;
50822 }
50823
50824
50825 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50826 PyObject *resultobj = 0;
50827 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50828 bool arg2 ;
50829 void *argp1 = 0 ;
50830 int res1 = 0 ;
50831 bool val2 ;
50832 int ecode2 = 0 ;
50833 PyObject * obj0 = 0 ;
50834 PyObject * obj1 = 0 ;
50835 char * kwnames[] = {
50836 (char *) "self",(char *) "show", NULL
50837 };
50838
50839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
50840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50841 if (!SWIG_IsOK(res1)) {
50842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50843 }
50844 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50845 ecode2 = SWIG_AsVal_bool(obj1, &val2);
50846 if (!SWIG_IsOK(ecode2)) {
50847 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
50848 }
50849 arg2 = static_cast< bool >(val2);
50850 {
50851 PyThreadState* __tstate = wxPyBeginAllowThreads();
50852 (arg1)->Show(arg2);
50853 wxPyEndAllowThreads(__tstate);
50854 if (PyErr_Occurred()) SWIG_fail;
50855 }
50856 resultobj = SWIG_Py_Void();
50857 return resultobj;
50858 fail:
50859 return NULL;
50860 }
50861
50862
50863 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50864 PyObject *resultobj = 0;
50865 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50866 bool result;
50867 void *argp1 = 0 ;
50868 int res1 = 0 ;
50869 PyObject *swig_obj[1] ;
50870
50871 if (!args) SWIG_fail;
50872 swig_obj[0] = args;
50873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50874 if (!SWIG_IsOK(res1)) {
50875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50876 }
50877 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50878 {
50879 PyThreadState* __tstate = wxPyBeginAllowThreads();
50880 result = (bool)(arg1)->IsShown();
50881 wxPyEndAllowThreads(__tstate);
50882 if (PyErr_Occurred()) SWIG_fail;
50883 }
50884 {
50885 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50886 }
50887 return resultobj;
50888 fail:
50889 return NULL;
50890 }
50891
50892
50893 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50894 PyObject *resultobj = 0;
50895 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50896 wxPoint result;
50897 void *argp1 = 0 ;
50898 int res1 = 0 ;
50899 PyObject *swig_obj[1] ;
50900
50901 if (!args) SWIG_fail;
50902 swig_obj[0] = args;
50903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50904 if (!SWIG_IsOK(res1)) {
50905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50906 }
50907 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50908 {
50909 PyThreadState* __tstate = wxPyBeginAllowThreads();
50910 result = (arg1)->GetPosition();
50911 wxPyEndAllowThreads(__tstate);
50912 if (PyErr_Occurred()) SWIG_fail;
50913 }
50914 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
50915 return resultobj;
50916 fail:
50917 return NULL;
50918 }
50919
50920
50921 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50922 PyObject *resultobj = 0;
50923 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50924 PyObject *result = 0 ;
50925 void *argp1 = 0 ;
50926 int res1 = 0 ;
50927 PyObject *swig_obj[1] ;
50928
50929 if (!args) SWIG_fail;
50930 swig_obj[0] = args;
50931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50932 if (!SWIG_IsOK(res1)) {
50933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50934 }
50935 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50936 {
50937 PyThreadState* __tstate = wxPyBeginAllowThreads();
50938 result = (PyObject *)wxSizerItem_GetUserData(arg1);
50939 wxPyEndAllowThreads(__tstate);
50940 if (PyErr_Occurred()) SWIG_fail;
50941 }
50942 resultobj = result;
50943 return resultobj;
50944 fail:
50945 return NULL;
50946 }
50947
50948
50949 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50950 PyObject *resultobj = 0;
50951 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50952 PyObject *arg2 = (PyObject *) 0 ;
50953 void *argp1 = 0 ;
50954 int res1 = 0 ;
50955 PyObject * obj0 = 0 ;
50956 PyObject * obj1 = 0 ;
50957 char * kwnames[] = {
50958 (char *) "self",(char *) "userData", NULL
50959 };
50960
50961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
50962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50963 if (!SWIG_IsOK(res1)) {
50964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50965 }
50966 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50967 arg2 = obj1;
50968 {
50969 PyThreadState* __tstate = wxPyBeginAllowThreads();
50970 wxSizerItem_SetUserData(arg1,arg2);
50971 wxPyEndAllowThreads(__tstate);
50972 if (PyErr_Occurred()) SWIG_fail;
50973 }
50974 resultobj = SWIG_Py_Void();
50975 return resultobj;
50976 fail:
50977 return NULL;
50978 }
50979
50980
50981 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50982 PyObject *obj;
50983 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50984 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
50985 return SWIG_Py_Void();
50986 }
50987
50988 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50989 return SWIG_Python_InitShadowInstance(args);
50990 }
50991
50992 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50993 PyObject *resultobj = 0;
50994 wxSizer *arg1 = (wxSizer *) 0 ;
50995 void *argp1 = 0 ;
50996 int res1 = 0 ;
50997 PyObject *swig_obj[1] ;
50998
50999 if (!args) SWIG_fail;
51000 swig_obj[0] = args;
51001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
51002 if (!SWIG_IsOK(res1)) {
51003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
51004 }
51005 arg1 = reinterpret_cast< wxSizer * >(argp1);
51006 {
51007 PyThreadState* __tstate = wxPyBeginAllowThreads();
51008 delete arg1;
51009
51010 wxPyEndAllowThreads(__tstate);
51011 if (PyErr_Occurred()) SWIG_fail;
51012 }
51013 resultobj = SWIG_Py_Void();
51014 return resultobj;
51015 fail:
51016 return NULL;
51017 }
51018
51019
51020 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51021 PyObject *resultobj = 0;
51022 wxSizer *arg1 = (wxSizer *) 0 ;
51023 PyObject *arg2 = (PyObject *) 0 ;
51024 void *argp1 = 0 ;
51025 int res1 = 0 ;
51026 PyObject * obj0 = 0 ;
51027 PyObject * obj1 = 0 ;
51028 char * kwnames[] = {
51029 (char *) "self",(char *) "_self", NULL
51030 };
51031
51032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
51033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51034 if (!SWIG_IsOK(res1)) {
51035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
51036 }
51037 arg1 = reinterpret_cast< wxSizer * >(argp1);
51038 arg2 = obj1;
51039 {
51040 PyThreadState* __tstate = wxPyBeginAllowThreads();
51041 wxSizer__setOORInfo(arg1,arg2);
51042 wxPyEndAllowThreads(__tstate);
51043 if (PyErr_Occurred()) SWIG_fail;
51044 }
51045 resultobj = SWIG_Py_Void();
51046 return resultobj;
51047 fail:
51048 return NULL;
51049 }
51050
51051
51052 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51053 PyObject *resultobj = 0;
51054 wxSizer *arg1 = (wxSizer *) 0 ;
51055 PyObject *arg2 = (PyObject *) 0 ;
51056 int arg3 = (int) 0 ;
51057 int arg4 = (int) 0 ;
51058 int arg5 = (int) 0 ;
51059 PyObject *arg6 = (PyObject *) NULL ;
51060 wxSizerItem *result = 0 ;
51061 void *argp1 = 0 ;
51062 int res1 = 0 ;
51063 int val3 ;
51064 int ecode3 = 0 ;
51065 int val4 ;
51066 int ecode4 = 0 ;
51067 int val5 ;
51068 int ecode5 = 0 ;
51069 PyObject * obj0 = 0 ;
51070 PyObject * obj1 = 0 ;
51071 PyObject * obj2 = 0 ;
51072 PyObject * obj3 = 0 ;
51073 PyObject * obj4 = 0 ;
51074 PyObject * obj5 = 0 ;
51075 char * kwnames[] = {
51076 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
51077 };
51078
51079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51081 if (!SWIG_IsOK(res1)) {
51082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
51083 }
51084 arg1 = reinterpret_cast< wxSizer * >(argp1);
51085 arg2 = obj1;
51086 if (obj2) {
51087 ecode3 = SWIG_AsVal_int(obj2, &val3);
51088 if (!SWIG_IsOK(ecode3)) {
51089 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
51090 }
51091 arg3 = static_cast< int >(val3);
51092 }
51093 if (obj3) {
51094 ecode4 = SWIG_AsVal_int(obj3, &val4);
51095 if (!SWIG_IsOK(ecode4)) {
51096 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
51097 }
51098 arg4 = static_cast< int >(val4);
51099 }
51100 if (obj4) {
51101 ecode5 = SWIG_AsVal_int(obj4, &val5);
51102 if (!SWIG_IsOK(ecode5)) {
51103 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
51104 }
51105 arg5 = static_cast< int >(val5);
51106 }
51107 if (obj5) {
51108 arg6 = obj5;
51109 }
51110 {
51111 PyThreadState* __tstate = wxPyBeginAllowThreads();
51112 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
51113 wxPyEndAllowThreads(__tstate);
51114 if (PyErr_Occurred()) SWIG_fail;
51115 }
51116 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51117 return resultobj;
51118 fail:
51119 return NULL;
51120 }
51121
51122
51123 SWIGINTERN PyObject *_wrap_Sizer_AddF(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51124 PyObject *resultobj = 0;
51125 wxSizer *arg1 = (wxSizer *) 0 ;
51126 PyObject *arg2 = (PyObject *) 0 ;
51127 wxSizerFlags *arg3 = 0 ;
51128 wxSizerItem *result = 0 ;
51129 void *argp1 = 0 ;
51130 int res1 = 0 ;
51131 void *argp3 = 0 ;
51132 int res3 = 0 ;
51133 PyObject * obj0 = 0 ;
51134 PyObject * obj1 = 0 ;
51135 PyObject * obj2 = 0 ;
51136 char * kwnames[] = {
51137 (char *) "self",(char *) "item",(char *) "flags", NULL
51138 };
51139
51140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_AddF",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51142 if (!SWIG_IsOK(res1)) {
51143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddF" "', expected argument " "1"" of type '" "wxSizer *""'");
51144 }
51145 arg1 = reinterpret_cast< wxSizer * >(argp1);
51146 arg2 = obj1;
51147 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxSizerFlags, 0 );
51148 if (!SWIG_IsOK(res3)) {
51149 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_AddF" "', expected argument " "3"" of type '" "wxSizerFlags &""'");
51150 }
51151 if (!argp3) {
51152 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sizer_AddF" "', expected argument " "3"" of type '" "wxSizerFlags &""'");
51153 }
51154 arg3 = reinterpret_cast< wxSizerFlags * >(argp3);
51155 {
51156 PyThreadState* __tstate = wxPyBeginAllowThreads();
51157 result = (wxSizerItem *)wxSizer_AddF(arg1,arg2,*arg3);
51158 wxPyEndAllowThreads(__tstate);
51159 if (PyErr_Occurred()) SWIG_fail;
51160 }
51161 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51162 return resultobj;
51163 fail:
51164 return NULL;
51165 }
51166
51167
51168 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51169 PyObject *resultobj = 0;
51170 wxSizer *arg1 = (wxSizer *) 0 ;
51171 int arg2 ;
51172 PyObject *arg3 = (PyObject *) 0 ;
51173 int arg4 = (int) 0 ;
51174 int arg5 = (int) 0 ;
51175 int arg6 = (int) 0 ;
51176 PyObject *arg7 = (PyObject *) NULL ;
51177 wxSizerItem *result = 0 ;
51178 void *argp1 = 0 ;
51179 int res1 = 0 ;
51180 int val2 ;
51181 int ecode2 = 0 ;
51182 int val4 ;
51183 int ecode4 = 0 ;
51184 int val5 ;
51185 int ecode5 = 0 ;
51186 int val6 ;
51187 int ecode6 = 0 ;
51188 PyObject * obj0 = 0 ;
51189 PyObject * obj1 = 0 ;
51190 PyObject * obj2 = 0 ;
51191 PyObject * obj3 = 0 ;
51192 PyObject * obj4 = 0 ;
51193 PyObject * obj5 = 0 ;
51194 PyObject * obj6 = 0 ;
51195 char * kwnames[] = {
51196 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
51197 };
51198
51199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
51200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51201 if (!SWIG_IsOK(res1)) {
51202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
51203 }
51204 arg1 = reinterpret_cast< wxSizer * >(argp1);
51205 ecode2 = SWIG_AsVal_int(obj1, &val2);
51206 if (!SWIG_IsOK(ecode2)) {
51207 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
51208 }
51209 arg2 = static_cast< int >(val2);
51210 arg3 = obj2;
51211 if (obj3) {
51212 ecode4 = SWIG_AsVal_int(obj3, &val4);
51213 if (!SWIG_IsOK(ecode4)) {
51214 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
51215 }
51216 arg4 = static_cast< int >(val4);
51217 }
51218 if (obj4) {
51219 ecode5 = SWIG_AsVal_int(obj4, &val5);
51220 if (!SWIG_IsOK(ecode5)) {
51221 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
51222 }
51223 arg5 = static_cast< int >(val5);
51224 }
51225 if (obj5) {
51226 ecode6 = SWIG_AsVal_int(obj5, &val6);
51227 if (!SWIG_IsOK(ecode6)) {
51228 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
51229 }
51230 arg6 = static_cast< int >(val6);
51231 }
51232 if (obj6) {
51233 arg7 = obj6;
51234 }
51235 {
51236 PyThreadState* __tstate = wxPyBeginAllowThreads();
51237 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
51238 wxPyEndAllowThreads(__tstate);
51239 if (PyErr_Occurred()) SWIG_fail;
51240 }
51241 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51242 return resultobj;
51243 fail:
51244 return NULL;
51245 }
51246
51247
51248 SWIGINTERN PyObject *_wrap_Sizer_InsertF(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51249 PyObject *resultobj = 0;
51250 wxSizer *arg1 = (wxSizer *) 0 ;
51251 int arg2 ;
51252 PyObject *arg3 = (PyObject *) 0 ;
51253 wxSizerFlags *arg4 = 0 ;
51254 wxSizerItem *result = 0 ;
51255 void *argp1 = 0 ;
51256 int res1 = 0 ;
51257 int val2 ;
51258 int ecode2 = 0 ;
51259 void *argp4 = 0 ;
51260 int res4 = 0 ;
51261 PyObject * obj0 = 0 ;
51262 PyObject * obj1 = 0 ;
51263 PyObject * obj2 = 0 ;
51264 PyObject * obj3 = 0 ;
51265 char * kwnames[] = {
51266 (char *) "self",(char *) "before",(char *) "item",(char *) "flags", NULL
51267 };
51268
51269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Sizer_InsertF",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51271 if (!SWIG_IsOK(res1)) {
51272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertF" "', expected argument " "1"" of type '" "wxSizer *""'");
51273 }
51274 arg1 = reinterpret_cast< wxSizer * >(argp1);
51275 ecode2 = SWIG_AsVal_int(obj1, &val2);
51276 if (!SWIG_IsOK(ecode2)) {
51277 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertF" "', expected argument " "2"" of type '" "int""'");
51278 }
51279 arg2 = static_cast< int >(val2);
51280 arg3 = obj2;
51281 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxSizerFlags, 0 );
51282 if (!SWIG_IsOK(res4)) {
51283 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Sizer_InsertF" "', expected argument " "4"" of type '" "wxSizerFlags &""'");
51284 }
51285 if (!argp4) {
51286 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sizer_InsertF" "', expected argument " "4"" of type '" "wxSizerFlags &""'");
51287 }
51288 arg4 = reinterpret_cast< wxSizerFlags * >(argp4);
51289 {
51290 PyThreadState* __tstate = wxPyBeginAllowThreads();
51291 result = (wxSizerItem *)wxSizer_InsertF(arg1,arg2,arg3,*arg4);
51292 wxPyEndAllowThreads(__tstate);
51293 if (PyErr_Occurred()) SWIG_fail;
51294 }
51295 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51296 return resultobj;
51297 fail:
51298 return NULL;
51299 }
51300
51301
51302 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51303 PyObject *resultobj = 0;
51304 wxSizer *arg1 = (wxSizer *) 0 ;
51305 PyObject *arg2 = (PyObject *) 0 ;
51306 int arg3 = (int) 0 ;
51307 int arg4 = (int) 0 ;
51308 int arg5 = (int) 0 ;
51309 PyObject *arg6 = (PyObject *) NULL ;
51310 wxSizerItem *result = 0 ;
51311 void *argp1 = 0 ;
51312 int res1 = 0 ;
51313 int val3 ;
51314 int ecode3 = 0 ;
51315 int val4 ;
51316 int ecode4 = 0 ;
51317 int val5 ;
51318 int ecode5 = 0 ;
51319 PyObject * obj0 = 0 ;
51320 PyObject * obj1 = 0 ;
51321 PyObject * obj2 = 0 ;
51322 PyObject * obj3 = 0 ;
51323 PyObject * obj4 = 0 ;
51324 PyObject * obj5 = 0 ;
51325 char * kwnames[] = {
51326 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
51327 };
51328
51329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51331 if (!SWIG_IsOK(res1)) {
51332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
51333 }
51334 arg1 = reinterpret_cast< wxSizer * >(argp1);
51335 arg2 = obj1;
51336 if (obj2) {
51337 ecode3 = SWIG_AsVal_int(obj2, &val3);
51338 if (!SWIG_IsOK(ecode3)) {
51339 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
51340 }
51341 arg3 = static_cast< int >(val3);
51342 }
51343 if (obj3) {
51344 ecode4 = SWIG_AsVal_int(obj3, &val4);
51345 if (!SWIG_IsOK(ecode4)) {
51346 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
51347 }
51348 arg4 = static_cast< int >(val4);
51349 }
51350 if (obj4) {
51351 ecode5 = SWIG_AsVal_int(obj4, &val5);
51352 if (!SWIG_IsOK(ecode5)) {
51353 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
51354 }
51355 arg5 = static_cast< int >(val5);
51356 }
51357 if (obj5) {
51358 arg6 = obj5;
51359 }
51360 {
51361 PyThreadState* __tstate = wxPyBeginAllowThreads();
51362 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
51363 wxPyEndAllowThreads(__tstate);
51364 if (PyErr_Occurred()) SWIG_fail;
51365 }
51366 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51367 return resultobj;
51368 fail:
51369 return NULL;
51370 }
51371
51372
51373 SWIGINTERN PyObject *_wrap_Sizer_PrependF(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51374 PyObject *resultobj = 0;
51375 wxSizer *arg1 = (wxSizer *) 0 ;
51376 PyObject *arg2 = (PyObject *) 0 ;
51377 wxSizerFlags *arg3 = 0 ;
51378 wxSizerItem *result = 0 ;
51379 void *argp1 = 0 ;
51380 int res1 = 0 ;
51381 void *argp3 = 0 ;
51382 int res3 = 0 ;
51383 PyObject * obj0 = 0 ;
51384 PyObject * obj1 = 0 ;
51385 PyObject * obj2 = 0 ;
51386 char * kwnames[] = {
51387 (char *) "self",(char *) "item",(char *) "flags", NULL
51388 };
51389
51390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_PrependF",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51392 if (!SWIG_IsOK(res1)) {
51393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependF" "', expected argument " "1"" of type '" "wxSizer *""'");
51394 }
51395 arg1 = reinterpret_cast< wxSizer * >(argp1);
51396 arg2 = obj1;
51397 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxSizerFlags, 0 );
51398 if (!SWIG_IsOK(res3)) {
51399 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_PrependF" "', expected argument " "3"" of type '" "wxSizerFlags &""'");
51400 }
51401 if (!argp3) {
51402 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sizer_PrependF" "', expected argument " "3"" of type '" "wxSizerFlags &""'");
51403 }
51404 arg3 = reinterpret_cast< wxSizerFlags * >(argp3);
51405 {
51406 PyThreadState* __tstate = wxPyBeginAllowThreads();
51407 result = (wxSizerItem *)wxSizer_PrependF(arg1,arg2,*arg3);
51408 wxPyEndAllowThreads(__tstate);
51409 if (PyErr_Occurred()) SWIG_fail;
51410 }
51411 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51412 return resultobj;
51413 fail:
51414 return NULL;
51415 }
51416
51417
51418 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51419 PyObject *resultobj = 0;
51420 wxSizer *arg1 = (wxSizer *) 0 ;
51421 PyObject *arg2 = (PyObject *) 0 ;
51422 bool result;
51423 void *argp1 = 0 ;
51424 int res1 = 0 ;
51425 PyObject * obj0 = 0 ;
51426 PyObject * obj1 = 0 ;
51427 char * kwnames[] = {
51428 (char *) "self",(char *) "item", NULL
51429 };
51430
51431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
51432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51433 if (!SWIG_IsOK(res1)) {
51434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
51435 }
51436 arg1 = reinterpret_cast< wxSizer * >(argp1);
51437 arg2 = obj1;
51438 {
51439 PyThreadState* __tstate = wxPyBeginAllowThreads();
51440 result = (bool)wxSizer_Remove(arg1,arg2);
51441 wxPyEndAllowThreads(__tstate);
51442 if (PyErr_Occurred()) SWIG_fail;
51443 }
51444 {
51445 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51446 }
51447 return resultobj;
51448 fail:
51449 return NULL;
51450 }
51451
51452
51453 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51454 PyObject *resultobj = 0;
51455 wxSizer *arg1 = (wxSizer *) 0 ;
51456 PyObject *arg2 = (PyObject *) 0 ;
51457 bool result;
51458 void *argp1 = 0 ;
51459 int res1 = 0 ;
51460 PyObject * obj0 = 0 ;
51461 PyObject * obj1 = 0 ;
51462 char * kwnames[] = {
51463 (char *) "self",(char *) "item", NULL
51464 };
51465
51466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
51467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51468 if (!SWIG_IsOK(res1)) {
51469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
51470 }
51471 arg1 = reinterpret_cast< wxSizer * >(argp1);
51472 arg2 = obj1;
51473 {
51474 PyThreadState* __tstate = wxPyBeginAllowThreads();
51475 result = (bool)wxSizer_Detach(arg1,arg2);
51476 wxPyEndAllowThreads(__tstate);
51477 if (PyErr_Occurred()) SWIG_fail;
51478 }
51479 {
51480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51481 }
51482 return resultobj;
51483 fail:
51484 return NULL;
51485 }
51486
51487
51488 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51489 PyObject *resultobj = 0;
51490 wxSizer *arg1 = (wxSizer *) 0 ;
51491 PyObject *arg2 = (PyObject *) 0 ;
51492 bool arg3 = (bool) false ;
51493 wxSizerItem *result = 0 ;
51494 void *argp1 = 0 ;
51495 int res1 = 0 ;
51496 bool val3 ;
51497 int ecode3 = 0 ;
51498 PyObject * obj0 = 0 ;
51499 PyObject * obj1 = 0 ;
51500 PyObject * obj2 = 0 ;
51501 char * kwnames[] = {
51502 (char *) "self",(char *) "item",(char *) "recursive", NULL
51503 };
51504
51505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Sizer_GetItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51507 if (!SWIG_IsOK(res1)) {
51508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
51509 }
51510 arg1 = reinterpret_cast< wxSizer * >(argp1);
51511 arg2 = obj1;
51512 if (obj2) {
51513 ecode3 = SWIG_AsVal_bool(obj2, &val3);
51514 if (!SWIG_IsOK(ecode3)) {
51515 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_GetItem" "', expected argument " "3"" of type '" "bool""'");
51516 }
51517 arg3 = static_cast< bool >(val3);
51518 }
51519 {
51520 PyThreadState* __tstate = wxPyBeginAllowThreads();
51521 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2,arg3);
51522 wxPyEndAllowThreads(__tstate);
51523 if (PyErr_Occurred()) SWIG_fail;
51524 }
51525 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51526 return resultobj;
51527 fail:
51528 return NULL;
51529 }
51530
51531
51532 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51533 PyObject *resultobj = 0;
51534 wxSizer *arg1 = (wxSizer *) 0 ;
51535 PyObject *arg2 = (PyObject *) 0 ;
51536 wxSize *arg3 = 0 ;
51537 void *argp1 = 0 ;
51538 int res1 = 0 ;
51539 wxSize temp3 ;
51540 PyObject * obj0 = 0 ;
51541 PyObject * obj1 = 0 ;
51542 PyObject * obj2 = 0 ;
51543 char * kwnames[] = {
51544 (char *) "self",(char *) "item",(char *) "size", NULL
51545 };
51546
51547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51549 if (!SWIG_IsOK(res1)) {
51550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
51551 }
51552 arg1 = reinterpret_cast< wxSizer * >(argp1);
51553 arg2 = obj1;
51554 {
51555 arg3 = &temp3;
51556 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
51557 }
51558 {
51559 PyThreadState* __tstate = wxPyBeginAllowThreads();
51560 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
51561 wxPyEndAllowThreads(__tstate);
51562 if (PyErr_Occurred()) SWIG_fail;
51563 }
51564 resultobj = SWIG_Py_Void();
51565 return resultobj;
51566 fail:
51567 return NULL;
51568 }
51569
51570
51571 SWIGINTERN PyObject *_wrap_Sizer__ReplaceWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51572 PyObject *resultobj = 0;
51573 wxSizer *arg1 = (wxSizer *) 0 ;
51574 wxWindow *arg2 = (wxWindow *) 0 ;
51575 wxWindow *arg3 = (wxWindow *) 0 ;
51576 bool arg4 = (bool) false ;
51577 bool result;
51578 void *argp1 = 0 ;
51579 int res1 = 0 ;
51580 void *argp2 = 0 ;
51581 int res2 = 0 ;
51582 void *argp3 = 0 ;
51583 int res3 = 0 ;
51584 bool val4 ;
51585 int ecode4 = 0 ;
51586 PyObject * obj0 = 0 ;
51587 PyObject * obj1 = 0 ;
51588 PyObject * obj2 = 0 ;
51589 PyObject * obj3 = 0 ;
51590 char * kwnames[] = {
51591 (char *) "self",(char *) "oldwin",(char *) "newwin",(char *) "recursive", NULL
51592 };
51593
51594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceWin",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51596 if (!SWIG_IsOK(res1)) {
51597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceWin" "', expected argument " "1"" of type '" "wxSizer *""'");
51598 }
51599 arg1 = reinterpret_cast< wxSizer * >(argp1);
51600 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51601 if (!SWIG_IsOK(res2)) {
51602 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceWin" "', expected argument " "2"" of type '" "wxWindow *""'");
51603 }
51604 arg2 = reinterpret_cast< wxWindow * >(argp2);
51605 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51606 if (!SWIG_IsOK(res3)) {
51607 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceWin" "', expected argument " "3"" of type '" "wxWindow *""'");
51608 }
51609 arg3 = reinterpret_cast< wxWindow * >(argp3);
51610 if (obj3) {
51611 ecode4 = SWIG_AsVal_bool(obj3, &val4);
51612 if (!SWIG_IsOK(ecode4)) {
51613 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceWin" "', expected argument " "4"" of type '" "bool""'");
51614 }
51615 arg4 = static_cast< bool >(val4);
51616 }
51617 {
51618 PyThreadState* __tstate = wxPyBeginAllowThreads();
51619 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
51620 wxPyEndAllowThreads(__tstate);
51621 if (PyErr_Occurred()) SWIG_fail;
51622 }
51623 {
51624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51625 }
51626 return resultobj;
51627 fail:
51628 return NULL;
51629 }
51630
51631
51632 SWIGINTERN PyObject *_wrap_Sizer__ReplaceSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51633 PyObject *resultobj = 0;
51634 wxSizer *arg1 = (wxSizer *) 0 ;
51635 wxSizer *arg2 = (wxSizer *) 0 ;
51636 wxSizer *arg3 = (wxSizer *) 0 ;
51637 bool arg4 = (bool) false ;
51638 bool result;
51639 void *argp1 = 0 ;
51640 int res1 = 0 ;
51641 void *argp2 = 0 ;
51642 int res2 = 0 ;
51643 void *argp3 = 0 ;
51644 int res3 = 0 ;
51645 bool val4 ;
51646 int ecode4 = 0 ;
51647 PyObject * obj0 = 0 ;
51648 PyObject * obj1 = 0 ;
51649 PyObject * obj2 = 0 ;
51650 PyObject * obj3 = 0 ;
51651 char * kwnames[] = {
51652 (char *) "self",(char *) "oldsz",(char *) "newsz",(char *) "recursive", NULL
51653 };
51654
51655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51657 if (!SWIG_IsOK(res1)) {
51658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
51659 }
51660 arg1 = reinterpret_cast< wxSizer * >(argp1);
51661 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51662 if (!SWIG_IsOK(res2)) {
51663 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
51664 }
51665 arg2 = reinterpret_cast< wxSizer * >(argp2);
51666 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizer, 0 | 0 );
51667 if (!SWIG_IsOK(res3)) {
51668 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceSizer" "', expected argument " "3"" of type '" "wxSizer *""'");
51669 }
51670 arg3 = reinterpret_cast< wxSizer * >(argp3);
51671 if (obj3) {
51672 ecode4 = SWIG_AsVal_bool(obj3, &val4);
51673 if (!SWIG_IsOK(ecode4)) {
51674 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceSizer" "', expected argument " "4"" of type '" "bool""'");
51675 }
51676 arg4 = static_cast< bool >(val4);
51677 }
51678 {
51679 PyThreadState* __tstate = wxPyBeginAllowThreads();
51680 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
51681 wxPyEndAllowThreads(__tstate);
51682 if (PyErr_Occurred()) SWIG_fail;
51683 }
51684 {
51685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51686 }
51687 return resultobj;
51688 fail:
51689 return NULL;
51690 }
51691
51692
51693 SWIGINTERN PyObject *_wrap_Sizer__ReplaceItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51694 PyObject *resultobj = 0;
51695 wxSizer *arg1 = (wxSizer *) 0 ;
51696 size_t arg2 ;
51697 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
51698 bool result;
51699 void *argp1 = 0 ;
51700 int res1 = 0 ;
51701 size_t val2 ;
51702 int ecode2 = 0 ;
51703 void *argp3 = 0 ;
51704 int res3 = 0 ;
51705 PyObject * obj0 = 0 ;
51706 PyObject * obj1 = 0 ;
51707 PyObject * obj2 = 0 ;
51708 char * kwnames[] = {
51709 (char *) "self",(char *) "index",(char *) "newitem", NULL
51710 };
51711
51712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__ReplaceItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51714 if (!SWIG_IsOK(res1)) {
51715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceItem" "', expected argument " "1"" of type '" "wxSizer *""'");
51716 }
51717 arg1 = reinterpret_cast< wxSizer * >(argp1);
51718 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51719 if (!SWIG_IsOK(ecode2)) {
51720 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer__ReplaceItem" "', expected argument " "2"" of type '" "size_t""'");
51721 }
51722 arg2 = static_cast< size_t >(val2);
51723 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51724 if (!SWIG_IsOK(res3)) {
51725 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
51726 }
51727 arg3 = reinterpret_cast< wxSizerItem * >(argp3);
51728 {
51729 PyThreadState* __tstate = wxPyBeginAllowThreads();
51730 result = (bool)(arg1)->Replace(arg2,arg3);
51731 wxPyEndAllowThreads(__tstate);
51732 if (PyErr_Occurred()) SWIG_fail;
51733 }
51734 {
51735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51736 }
51737 return resultobj;
51738 fail:
51739 return NULL;
51740 }
51741
51742
51743 SWIGINTERN PyObject *_wrap_Sizer_SetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51744 PyObject *resultobj = 0;
51745 wxSizer *arg1 = (wxSizer *) 0 ;
51746 wxWindow *arg2 = (wxWindow *) 0 ;
51747 void *argp1 = 0 ;
51748 int res1 = 0 ;
51749 void *argp2 = 0 ;
51750 int res2 = 0 ;
51751 PyObject * obj0 = 0 ;
51752 PyObject * obj1 = 0 ;
51753 char * kwnames[] = {
51754 (char *) "self",(char *) "window", NULL
51755 };
51756
51757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetContainingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
51758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51759 if (!SWIG_IsOK(res1)) {
51760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetContainingWindow" "', expected argument " "1"" of type '" "wxSizer *""'");
51761 }
51762 arg1 = reinterpret_cast< wxSizer * >(argp1);
51763 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51764 if (!SWIG_IsOK(res2)) {
51765 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetContainingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
51766 }
51767 arg2 = reinterpret_cast< wxWindow * >(argp2);
51768 {
51769 PyThreadState* __tstate = wxPyBeginAllowThreads();
51770 (arg1)->SetContainingWindow(arg2);
51771 wxPyEndAllowThreads(__tstate);
51772 if (PyErr_Occurred()) SWIG_fail;
51773 }
51774 resultobj = SWIG_Py_Void();
51775 return resultobj;
51776 fail:
51777 return NULL;
51778 }
51779
51780
51781 SWIGINTERN PyObject *_wrap_Sizer_GetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51782 PyObject *resultobj = 0;
51783 wxSizer *arg1 = (wxSizer *) 0 ;
51784 wxWindow *result = 0 ;
51785 void *argp1 = 0 ;
51786 int res1 = 0 ;
51787 PyObject *swig_obj[1] ;
51788
51789 if (!args) SWIG_fail;
51790 swig_obj[0] = args;
51791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51792 if (!SWIG_IsOK(res1)) {
51793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetContainingWindow" "', expected argument " "1"" of type '" "wxSizer const *""'");
51794 }
51795 arg1 = reinterpret_cast< wxSizer * >(argp1);
51796 {
51797 PyThreadState* __tstate = wxPyBeginAllowThreads();
51798 result = (wxWindow *)((wxSizer const *)arg1)->GetContainingWindow();
51799 wxPyEndAllowThreads(__tstate);
51800 if (PyErr_Occurred()) SWIG_fail;
51801 }
51802 {
51803 resultobj = wxPyMake_wxObject(result, 0);
51804 }
51805 return resultobj;
51806 fail:
51807 return NULL;
51808 }
51809
51810
51811 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51812 PyObject *resultobj = 0;
51813 wxSizer *arg1 = (wxSizer *) 0 ;
51814 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
51815 wxSizerItem *result = 0 ;
51816 void *argp1 = 0 ;
51817 int res1 = 0 ;
51818 int res2 = 0 ;
51819 PyObject * obj0 = 0 ;
51820 PyObject * obj1 = 0 ;
51821 char * kwnames[] = {
51822 (char *) "self",(char *) "item", NULL
51823 };
51824
51825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
51826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51827 if (!SWIG_IsOK(res1)) {
51828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
51829 }
51830 arg1 = reinterpret_cast< wxSizer * >(argp1);
51831 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
51832 if (!SWIG_IsOK(res2)) {
51833 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
51834 }
51835 {
51836 PyThreadState* __tstate = wxPyBeginAllowThreads();
51837 result = (wxSizerItem *)(arg1)->Add(arg2);
51838 wxPyEndAllowThreads(__tstate);
51839 if (PyErr_Occurred()) SWIG_fail;
51840 }
51841 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51842 return resultobj;
51843 fail:
51844 return NULL;
51845 }
51846
51847
51848 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51849 PyObject *resultobj = 0;
51850 wxSizer *arg1 = (wxSizer *) 0 ;
51851 size_t arg2 ;
51852 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
51853 wxSizerItem *result = 0 ;
51854 void *argp1 = 0 ;
51855 int res1 = 0 ;
51856 size_t val2 ;
51857 int ecode2 = 0 ;
51858 int res3 = 0 ;
51859 PyObject * obj0 = 0 ;
51860 PyObject * obj1 = 0 ;
51861 PyObject * obj2 = 0 ;
51862 char * kwnames[] = {
51863 (char *) "self",(char *) "index",(char *) "item", NULL
51864 };
51865
51866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51868 if (!SWIG_IsOK(res1)) {
51869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
51870 }
51871 arg1 = reinterpret_cast< wxSizer * >(argp1);
51872 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51873 if (!SWIG_IsOK(ecode2)) {
51874 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
51875 }
51876 arg2 = static_cast< size_t >(val2);
51877 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
51878 if (!SWIG_IsOK(res3)) {
51879 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
51880 }
51881 {
51882 PyThreadState* __tstate = wxPyBeginAllowThreads();
51883 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
51884 wxPyEndAllowThreads(__tstate);
51885 if (PyErr_Occurred()) SWIG_fail;
51886 }
51887 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51888 return resultobj;
51889 fail:
51890 return NULL;
51891 }
51892
51893
51894 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51895 PyObject *resultobj = 0;
51896 wxSizer *arg1 = (wxSizer *) 0 ;
51897 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
51898 wxSizerItem *result = 0 ;
51899 void *argp1 = 0 ;
51900 int res1 = 0 ;
51901 int res2 = 0 ;
51902 PyObject * obj0 = 0 ;
51903 PyObject * obj1 = 0 ;
51904 char * kwnames[] = {
51905 (char *) "self",(char *) "item", NULL
51906 };
51907
51908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
51909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51910 if (!SWIG_IsOK(res1)) {
51911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
51912 }
51913 arg1 = reinterpret_cast< wxSizer * >(argp1);
51914 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
51915 if (!SWIG_IsOK(res2)) {
51916 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
51917 }
51918 {
51919 PyThreadState* __tstate = wxPyBeginAllowThreads();
51920 result = (wxSizerItem *)(arg1)->Prepend(arg2);
51921 wxPyEndAllowThreads(__tstate);
51922 if (PyErr_Occurred()) SWIG_fail;
51923 }
51924 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51925 return resultobj;
51926 fail:
51927 return NULL;
51928 }
51929
51930
51931 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51932 PyObject *resultobj = 0;
51933 wxSizer *arg1 = (wxSizer *) 0 ;
51934 int arg2 ;
51935 int arg3 ;
51936 int arg4 ;
51937 int arg5 ;
51938 void *argp1 = 0 ;
51939 int res1 = 0 ;
51940 int val2 ;
51941 int ecode2 = 0 ;
51942 int val3 ;
51943 int ecode3 = 0 ;
51944 int val4 ;
51945 int ecode4 = 0 ;
51946 int val5 ;
51947 int ecode5 = 0 ;
51948 PyObject * obj0 = 0 ;
51949 PyObject * obj1 = 0 ;
51950 PyObject * obj2 = 0 ;
51951 PyObject * obj3 = 0 ;
51952 PyObject * obj4 = 0 ;
51953 char * kwnames[] = {
51954 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
51955 };
51956
51957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
51958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51959 if (!SWIG_IsOK(res1)) {
51960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
51961 }
51962 arg1 = reinterpret_cast< wxSizer * >(argp1);
51963 ecode2 = SWIG_AsVal_int(obj1, &val2);
51964 if (!SWIG_IsOK(ecode2)) {
51965 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
51966 }
51967 arg2 = static_cast< int >(val2);
51968 ecode3 = SWIG_AsVal_int(obj2, &val3);
51969 if (!SWIG_IsOK(ecode3)) {
51970 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
51971 }
51972 arg3 = static_cast< int >(val3);
51973 ecode4 = SWIG_AsVal_int(obj3, &val4);
51974 if (!SWIG_IsOK(ecode4)) {
51975 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
51976 }
51977 arg4 = static_cast< int >(val4);
51978 ecode5 = SWIG_AsVal_int(obj4, &val5);
51979 if (!SWIG_IsOK(ecode5)) {
51980 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
51981 }
51982 arg5 = static_cast< int >(val5);
51983 {
51984 PyThreadState* __tstate = wxPyBeginAllowThreads();
51985 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
51986 wxPyEndAllowThreads(__tstate);
51987 if (PyErr_Occurred()) SWIG_fail;
51988 }
51989 resultobj = SWIG_Py_Void();
51990 return resultobj;
51991 fail:
51992 return NULL;
51993 }
51994
51995
51996 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51997 PyObject *resultobj = 0;
51998 wxSizer *arg1 = (wxSizer *) 0 ;
51999 wxSize *arg2 = 0 ;
52000 void *argp1 = 0 ;
52001 int res1 = 0 ;
52002 wxSize temp2 ;
52003 PyObject * obj0 = 0 ;
52004 PyObject * obj1 = 0 ;
52005 char * kwnames[] = {
52006 (char *) "self",(char *) "size", NULL
52007 };
52008
52009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
52010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52011 if (!SWIG_IsOK(res1)) {
52012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
52013 }
52014 arg1 = reinterpret_cast< wxSizer * >(argp1);
52015 {
52016 arg2 = &temp2;
52017 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
52018 }
52019 {
52020 PyThreadState* __tstate = wxPyBeginAllowThreads();
52021 (arg1)->SetMinSize((wxSize const &)*arg2);
52022 wxPyEndAllowThreads(__tstate);
52023 if (PyErr_Occurred()) SWIG_fail;
52024 }
52025 resultobj = SWIG_Py_Void();
52026 return resultobj;
52027 fail:
52028 return NULL;
52029 }
52030
52031
52032 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52033 PyObject *resultobj = 0;
52034 wxSizer *arg1 = (wxSizer *) 0 ;
52035 wxSize result;
52036 void *argp1 = 0 ;
52037 int res1 = 0 ;
52038 PyObject *swig_obj[1] ;
52039
52040 if (!args) SWIG_fail;
52041 swig_obj[0] = args;
52042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52043 if (!SWIG_IsOK(res1)) {
52044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
52045 }
52046 arg1 = reinterpret_cast< wxSizer * >(argp1);
52047 {
52048 PyThreadState* __tstate = wxPyBeginAllowThreads();
52049 result = (arg1)->GetSize();
52050 wxPyEndAllowThreads(__tstate);
52051 if (PyErr_Occurred()) SWIG_fail;
52052 }
52053 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
52054 return resultobj;
52055 fail:
52056 return NULL;
52057 }
52058
52059
52060 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52061 PyObject *resultobj = 0;
52062 wxSizer *arg1 = (wxSizer *) 0 ;
52063 wxPoint result;
52064 void *argp1 = 0 ;
52065 int res1 = 0 ;
52066 PyObject *swig_obj[1] ;
52067
52068 if (!args) SWIG_fail;
52069 swig_obj[0] = args;
52070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52071 if (!SWIG_IsOK(res1)) {
52072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
52073 }
52074 arg1 = reinterpret_cast< wxSizer * >(argp1);
52075 {
52076 PyThreadState* __tstate = wxPyBeginAllowThreads();
52077 result = (arg1)->GetPosition();
52078 wxPyEndAllowThreads(__tstate);
52079 if (PyErr_Occurred()) SWIG_fail;
52080 }
52081 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
52082 return resultobj;
52083 fail:
52084 return NULL;
52085 }
52086
52087
52088 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52089 PyObject *resultobj = 0;
52090 wxSizer *arg1 = (wxSizer *) 0 ;
52091 wxSize result;
52092 void *argp1 = 0 ;
52093 int res1 = 0 ;
52094 PyObject *swig_obj[1] ;
52095
52096 if (!args) SWIG_fail;
52097 swig_obj[0] = args;
52098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52099 if (!SWIG_IsOK(res1)) {
52100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
52101 }
52102 arg1 = reinterpret_cast< wxSizer * >(argp1);
52103 {
52104 PyThreadState* __tstate = wxPyBeginAllowThreads();
52105 result = (arg1)->GetMinSize();
52106 wxPyEndAllowThreads(__tstate);
52107 if (PyErr_Occurred()) SWIG_fail;
52108 }
52109 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
52110 return resultobj;
52111 fail:
52112 return NULL;
52113 }
52114
52115
52116 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52117 PyObject *resultobj = 0;
52118 wxSizer *arg1 = (wxSizer *) 0 ;
52119 void *argp1 = 0 ;
52120 int res1 = 0 ;
52121 PyObject *swig_obj[1] ;
52122
52123 if (!args) SWIG_fail;
52124 swig_obj[0] = args;
52125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52126 if (!SWIG_IsOK(res1)) {
52127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
52128 }
52129 arg1 = reinterpret_cast< wxSizer * >(argp1);
52130 {
52131 PyThreadState* __tstate = wxPyBeginAllowThreads();
52132 (arg1)->RecalcSizes();
52133 wxPyEndAllowThreads(__tstate);
52134 if (PyErr_Occurred()) SWIG_fail;
52135 }
52136 resultobj = SWIG_Py_Void();
52137 return resultobj;
52138 fail:
52139 return NULL;
52140 }
52141
52142
52143 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52144 PyObject *resultobj = 0;
52145 wxSizer *arg1 = (wxSizer *) 0 ;
52146 wxSize result;
52147 void *argp1 = 0 ;
52148 int res1 = 0 ;
52149 PyObject *swig_obj[1] ;
52150
52151 if (!args) SWIG_fail;
52152 swig_obj[0] = args;
52153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52154 if (!SWIG_IsOK(res1)) {
52155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
52156 }
52157 arg1 = reinterpret_cast< wxSizer * >(argp1);
52158 {
52159 PyThreadState* __tstate = wxPyBeginAllowThreads();
52160 result = (arg1)->CalcMin();
52161 wxPyEndAllowThreads(__tstate);
52162 if (PyErr_Occurred()) SWIG_fail;
52163 }
52164 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
52165 return resultobj;
52166 fail:
52167 return NULL;
52168 }
52169
52170
52171 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52172 PyObject *resultobj = 0;
52173 wxSizer *arg1 = (wxSizer *) 0 ;
52174 void *argp1 = 0 ;
52175 int res1 = 0 ;
52176 PyObject *swig_obj[1] ;
52177
52178 if (!args) SWIG_fail;
52179 swig_obj[0] = args;
52180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52181 if (!SWIG_IsOK(res1)) {
52182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
52183 }
52184 arg1 = reinterpret_cast< wxSizer * >(argp1);
52185 {
52186 PyThreadState* __tstate = wxPyBeginAllowThreads();
52187 (arg1)->Layout();
52188 wxPyEndAllowThreads(__tstate);
52189 if (PyErr_Occurred()) SWIG_fail;
52190 }
52191 resultobj = SWIG_Py_Void();
52192 return resultobj;
52193 fail:
52194 return NULL;
52195 }
52196
52197
52198 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52199 PyObject *resultobj = 0;
52200 wxSizer *arg1 = (wxSizer *) 0 ;
52201 wxWindow *arg2 = (wxWindow *) 0 ;
52202 wxSize result;
52203 void *argp1 = 0 ;
52204 int res1 = 0 ;
52205 void *argp2 = 0 ;
52206 int res2 = 0 ;
52207 PyObject * obj0 = 0 ;
52208 PyObject * obj1 = 0 ;
52209 char * kwnames[] = {
52210 (char *) "self",(char *) "window", NULL
52211 };
52212
52213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
52214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52215 if (!SWIG_IsOK(res1)) {
52216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
52217 }
52218 arg1 = reinterpret_cast< wxSizer * >(argp1);
52219 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52220 if (!SWIG_IsOK(res2)) {
52221 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
52222 }
52223 arg2 = reinterpret_cast< wxWindow * >(argp2);
52224 {
52225 PyThreadState* __tstate = wxPyBeginAllowThreads();
52226 result = (arg1)->Fit(arg2);
52227 wxPyEndAllowThreads(__tstate);
52228 if (PyErr_Occurred()) SWIG_fail;
52229 }
52230 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
52231 return resultobj;
52232 fail:
52233 return NULL;
52234 }
52235
52236
52237 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52238 PyObject *resultobj = 0;
52239 wxSizer *arg1 = (wxSizer *) 0 ;
52240 wxWindow *arg2 = (wxWindow *) 0 ;
52241 void *argp1 = 0 ;
52242 int res1 = 0 ;
52243 void *argp2 = 0 ;
52244 int res2 = 0 ;
52245 PyObject * obj0 = 0 ;
52246 PyObject * obj1 = 0 ;
52247 char * kwnames[] = {
52248 (char *) "self",(char *) "window", NULL
52249 };
52250
52251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
52252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52253 if (!SWIG_IsOK(res1)) {
52254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
52255 }
52256 arg1 = reinterpret_cast< wxSizer * >(argp1);
52257 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52258 if (!SWIG_IsOK(res2)) {
52259 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
52260 }
52261 arg2 = reinterpret_cast< wxWindow * >(argp2);
52262 {
52263 PyThreadState* __tstate = wxPyBeginAllowThreads();
52264 (arg1)->FitInside(arg2);
52265 wxPyEndAllowThreads(__tstate);
52266 if (PyErr_Occurred()) SWIG_fail;
52267 }
52268 resultobj = SWIG_Py_Void();
52269 return resultobj;
52270 fail:
52271 return NULL;
52272 }
52273
52274
52275 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52276 PyObject *resultobj = 0;
52277 wxSizer *arg1 = (wxSizer *) 0 ;
52278 wxWindow *arg2 = (wxWindow *) 0 ;
52279 void *argp1 = 0 ;
52280 int res1 = 0 ;
52281 void *argp2 = 0 ;
52282 int res2 = 0 ;
52283 PyObject * obj0 = 0 ;
52284 PyObject * obj1 = 0 ;
52285 char * kwnames[] = {
52286 (char *) "self",(char *) "window", NULL
52287 };
52288
52289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
52290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52291 if (!SWIG_IsOK(res1)) {
52292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
52293 }
52294 arg1 = reinterpret_cast< wxSizer * >(argp1);
52295 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52296 if (!SWIG_IsOK(res2)) {
52297 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
52298 }
52299 arg2 = reinterpret_cast< wxWindow * >(argp2);
52300 {
52301 PyThreadState* __tstate = wxPyBeginAllowThreads();
52302 (arg1)->SetSizeHints(arg2);
52303 wxPyEndAllowThreads(__tstate);
52304 if (PyErr_Occurred()) SWIG_fail;
52305 }
52306 resultobj = SWIG_Py_Void();
52307 return resultobj;
52308 fail:
52309 return NULL;
52310 }
52311
52312
52313 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52314 PyObject *resultobj = 0;
52315 wxSizer *arg1 = (wxSizer *) 0 ;
52316 wxWindow *arg2 = (wxWindow *) 0 ;
52317 void *argp1 = 0 ;
52318 int res1 = 0 ;
52319 void *argp2 = 0 ;
52320 int res2 = 0 ;
52321 PyObject * obj0 = 0 ;
52322 PyObject * obj1 = 0 ;
52323 char * kwnames[] = {
52324 (char *) "self",(char *) "window", NULL
52325 };
52326
52327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
52328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52329 if (!SWIG_IsOK(res1)) {
52330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
52331 }
52332 arg1 = reinterpret_cast< wxSizer * >(argp1);
52333 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52334 if (!SWIG_IsOK(res2)) {
52335 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
52336 }
52337 arg2 = reinterpret_cast< wxWindow * >(argp2);
52338 {
52339 PyThreadState* __tstate = wxPyBeginAllowThreads();
52340 (arg1)->SetVirtualSizeHints(arg2);
52341 wxPyEndAllowThreads(__tstate);
52342 if (PyErr_Occurred()) SWIG_fail;
52343 }
52344 resultobj = SWIG_Py_Void();
52345 return resultobj;
52346 fail:
52347 return NULL;
52348 }
52349
52350
52351 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52352 PyObject *resultobj = 0;
52353 wxSizer *arg1 = (wxSizer *) 0 ;
52354 bool arg2 = (bool) false ;
52355 void *argp1 = 0 ;
52356 int res1 = 0 ;
52357 bool val2 ;
52358 int ecode2 = 0 ;
52359 PyObject * obj0 = 0 ;
52360 PyObject * obj1 = 0 ;
52361 char * kwnames[] = {
52362 (char *) "self",(char *) "deleteWindows", NULL
52363 };
52364
52365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
52366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52367 if (!SWIG_IsOK(res1)) {
52368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
52369 }
52370 arg1 = reinterpret_cast< wxSizer * >(argp1);
52371 if (obj1) {
52372 ecode2 = SWIG_AsVal_bool(obj1, &val2);
52373 if (!SWIG_IsOK(ecode2)) {
52374 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
52375 }
52376 arg2 = static_cast< bool >(val2);
52377 }
52378 {
52379 PyThreadState* __tstate = wxPyBeginAllowThreads();
52380 (arg1)->Clear(arg2);
52381 wxPyEndAllowThreads(__tstate);
52382 if (PyErr_Occurred()) SWIG_fail;
52383 }
52384 resultobj = SWIG_Py_Void();
52385 return resultobj;
52386 fail:
52387 return NULL;
52388 }
52389
52390
52391 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52392 PyObject *resultobj = 0;
52393 wxSizer *arg1 = (wxSizer *) 0 ;
52394 void *argp1 = 0 ;
52395 int res1 = 0 ;
52396 PyObject *swig_obj[1] ;
52397
52398 if (!args) SWIG_fail;
52399 swig_obj[0] = args;
52400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52401 if (!SWIG_IsOK(res1)) {
52402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
52403 }
52404 arg1 = reinterpret_cast< wxSizer * >(argp1);
52405 {
52406 PyThreadState* __tstate = wxPyBeginAllowThreads();
52407 (arg1)->DeleteWindows();
52408 wxPyEndAllowThreads(__tstate);
52409 if (PyErr_Occurred()) SWIG_fail;
52410 }
52411 resultobj = SWIG_Py_Void();
52412 return resultobj;
52413 fail:
52414 return NULL;
52415 }
52416
52417
52418 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52419 PyObject *resultobj = 0;
52420 wxSizer *arg1 = (wxSizer *) 0 ;
52421 PyObject *result = 0 ;
52422 void *argp1 = 0 ;
52423 int res1 = 0 ;
52424 PyObject *swig_obj[1] ;
52425
52426 if (!args) SWIG_fail;
52427 swig_obj[0] = args;
52428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52429 if (!SWIG_IsOK(res1)) {
52430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
52431 }
52432 arg1 = reinterpret_cast< wxSizer * >(argp1);
52433 {
52434 PyThreadState* __tstate = wxPyBeginAllowThreads();
52435 result = (PyObject *)wxSizer_GetChildren(arg1);
52436 wxPyEndAllowThreads(__tstate);
52437 if (PyErr_Occurred()) SWIG_fail;
52438 }
52439 resultobj = result;
52440 return resultobj;
52441 fail:
52442 return NULL;
52443 }
52444
52445
52446 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52447 PyObject *resultobj = 0;
52448 wxSizer *arg1 = (wxSizer *) 0 ;
52449 PyObject *arg2 = (PyObject *) 0 ;
52450 bool arg3 = (bool) true ;
52451 bool arg4 = (bool) false ;
52452 bool result;
52453 void *argp1 = 0 ;
52454 int res1 = 0 ;
52455 bool val3 ;
52456 int ecode3 = 0 ;
52457 bool val4 ;
52458 int ecode4 = 0 ;
52459 PyObject * obj0 = 0 ;
52460 PyObject * obj1 = 0 ;
52461 PyObject * obj2 = 0 ;
52462 PyObject * obj3 = 0 ;
52463 char * kwnames[] = {
52464 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
52465 };
52466
52467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52469 if (!SWIG_IsOK(res1)) {
52470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
52471 }
52472 arg1 = reinterpret_cast< wxSizer * >(argp1);
52473 arg2 = obj1;
52474 if (obj2) {
52475 ecode3 = SWIG_AsVal_bool(obj2, &val3);
52476 if (!SWIG_IsOK(ecode3)) {
52477 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
52478 }
52479 arg3 = static_cast< bool >(val3);
52480 }
52481 if (obj3) {
52482 ecode4 = SWIG_AsVal_bool(obj3, &val4);
52483 if (!SWIG_IsOK(ecode4)) {
52484 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
52485 }
52486 arg4 = static_cast< bool >(val4);
52487 }
52488 {
52489 PyThreadState* __tstate = wxPyBeginAllowThreads();
52490 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
52491 wxPyEndAllowThreads(__tstate);
52492 if (PyErr_Occurred()) SWIG_fail;
52493 }
52494 {
52495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52496 }
52497 return resultobj;
52498 fail:
52499 return NULL;
52500 }
52501
52502
52503 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52504 PyObject *resultobj = 0;
52505 wxSizer *arg1 = (wxSizer *) 0 ;
52506 PyObject *arg2 = (PyObject *) 0 ;
52507 bool result;
52508 void *argp1 = 0 ;
52509 int res1 = 0 ;
52510 PyObject * obj0 = 0 ;
52511 PyObject * obj1 = 0 ;
52512 char * kwnames[] = {
52513 (char *) "self",(char *) "item", NULL
52514 };
52515
52516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
52517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52518 if (!SWIG_IsOK(res1)) {
52519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
52520 }
52521 arg1 = reinterpret_cast< wxSizer * >(argp1);
52522 arg2 = obj1;
52523 {
52524 PyThreadState* __tstate = wxPyBeginAllowThreads();
52525 result = (bool)wxSizer_IsShown(arg1,arg2);
52526 wxPyEndAllowThreads(__tstate);
52527 if (PyErr_Occurred()) SWIG_fail;
52528 }
52529 {
52530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52531 }
52532 return resultobj;
52533 fail:
52534 return NULL;
52535 }
52536
52537
52538 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52539 PyObject *resultobj = 0;
52540 wxSizer *arg1 = (wxSizer *) 0 ;
52541 bool arg2 ;
52542 void *argp1 = 0 ;
52543 int res1 = 0 ;
52544 bool val2 ;
52545 int ecode2 = 0 ;
52546 PyObject * obj0 = 0 ;
52547 PyObject * obj1 = 0 ;
52548 char * kwnames[] = {
52549 (char *) "self",(char *) "show", NULL
52550 };
52551
52552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
52553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52554 if (!SWIG_IsOK(res1)) {
52555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
52556 }
52557 arg1 = reinterpret_cast< wxSizer * >(argp1);
52558 ecode2 = SWIG_AsVal_bool(obj1, &val2);
52559 if (!SWIG_IsOK(ecode2)) {
52560 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
52561 }
52562 arg2 = static_cast< bool >(val2);
52563 {
52564 PyThreadState* __tstate = wxPyBeginAllowThreads();
52565 (arg1)->ShowItems(arg2);
52566 wxPyEndAllowThreads(__tstate);
52567 if (PyErr_Occurred()) SWIG_fail;
52568 }
52569 resultobj = SWIG_Py_Void();
52570 return resultobj;
52571 fail:
52572 return NULL;
52573 }
52574
52575
52576 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52577 PyObject *obj;
52578 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52579 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
52580 return SWIG_Py_Void();
52581 }
52582
52583 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52584 PyObject *resultobj = 0;
52585 wxPySizer *result = 0 ;
52586
52587 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
52588 {
52589 PyThreadState* __tstate = wxPyBeginAllowThreads();
52590 result = (wxPySizer *)new wxPySizer();
52591 wxPyEndAllowThreads(__tstate);
52592 if (PyErr_Occurred()) SWIG_fail;
52593 }
52594 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
52595 return resultobj;
52596 fail:
52597 return NULL;
52598 }
52599
52600
52601 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52602 PyObject *resultobj = 0;
52603 wxPySizer *arg1 = (wxPySizer *) 0 ;
52604 PyObject *arg2 = (PyObject *) 0 ;
52605 PyObject *arg3 = (PyObject *) 0 ;
52606 void *argp1 = 0 ;
52607 int res1 = 0 ;
52608 PyObject * obj0 = 0 ;
52609 PyObject * obj1 = 0 ;
52610 PyObject * obj2 = 0 ;
52611 char * kwnames[] = {
52612 (char *) "self",(char *) "self",(char *) "_class", NULL
52613 };
52614
52615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
52617 if (!SWIG_IsOK(res1)) {
52618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
52619 }
52620 arg1 = reinterpret_cast< wxPySizer * >(argp1);
52621 arg2 = obj1;
52622 arg3 = obj2;
52623 {
52624 PyThreadState* __tstate = wxPyBeginAllowThreads();
52625 (arg1)->_setCallbackInfo(arg2,arg3);
52626 wxPyEndAllowThreads(__tstate);
52627 if (PyErr_Occurred()) SWIG_fail;
52628 }
52629 resultobj = SWIG_Py_Void();
52630 return resultobj;
52631 fail:
52632 return NULL;
52633 }
52634
52635
52636 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52637 PyObject *obj;
52638 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52639 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
52640 return SWIG_Py_Void();
52641 }
52642
52643 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52644 return SWIG_Python_InitShadowInstance(args);
52645 }
52646
52647 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52648 PyObject *resultobj = 0;
52649 int arg1 = (int) wxHORIZONTAL ;
52650 wxBoxSizer *result = 0 ;
52651 int val1 ;
52652 int ecode1 = 0 ;
52653 PyObject * obj0 = 0 ;
52654 char * kwnames[] = {
52655 (char *) "orient", NULL
52656 };
52657
52658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
52659 if (obj0) {
52660 ecode1 = SWIG_AsVal_int(obj0, &val1);
52661 if (!SWIG_IsOK(ecode1)) {
52662 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
52663 }
52664 arg1 = static_cast< int >(val1);
52665 }
52666 {
52667 PyThreadState* __tstate = wxPyBeginAllowThreads();
52668 result = (wxBoxSizer *)new wxBoxSizer(arg1);
52669 wxPyEndAllowThreads(__tstate);
52670 if (PyErr_Occurred()) SWIG_fail;
52671 }
52672 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
52673 return resultobj;
52674 fail:
52675 return NULL;
52676 }
52677
52678
52679 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52680 PyObject *resultobj = 0;
52681 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
52682 int result;
52683 void *argp1 = 0 ;
52684 int res1 = 0 ;
52685 PyObject *swig_obj[1] ;
52686
52687 if (!args) SWIG_fail;
52688 swig_obj[0] = args;
52689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
52690 if (!SWIG_IsOK(res1)) {
52691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
52692 }
52693 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
52694 {
52695 PyThreadState* __tstate = wxPyBeginAllowThreads();
52696 result = (int)(arg1)->GetOrientation();
52697 wxPyEndAllowThreads(__tstate);
52698 if (PyErr_Occurred()) SWIG_fail;
52699 }
52700 resultobj = SWIG_From_int(static_cast< int >(result));
52701 return resultobj;
52702 fail:
52703 return NULL;
52704 }
52705
52706
52707 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52708 PyObject *resultobj = 0;
52709 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
52710 int arg2 ;
52711 void *argp1 = 0 ;
52712 int res1 = 0 ;
52713 int val2 ;
52714 int ecode2 = 0 ;
52715 PyObject * obj0 = 0 ;
52716 PyObject * obj1 = 0 ;
52717 char * kwnames[] = {
52718 (char *) "self",(char *) "orient", NULL
52719 };
52720
52721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
52722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
52723 if (!SWIG_IsOK(res1)) {
52724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
52725 }
52726 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
52727 ecode2 = SWIG_AsVal_int(obj1, &val2);
52728 if (!SWIG_IsOK(ecode2)) {
52729 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
52730 }
52731 arg2 = static_cast< int >(val2);
52732 {
52733 PyThreadState* __tstate = wxPyBeginAllowThreads();
52734 (arg1)->SetOrientation(arg2);
52735 wxPyEndAllowThreads(__tstate);
52736 if (PyErr_Occurred()) SWIG_fail;
52737 }
52738 resultobj = SWIG_Py_Void();
52739 return resultobj;
52740 fail:
52741 return NULL;
52742 }
52743
52744
52745 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52746 PyObject *obj;
52747 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52748 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
52749 return SWIG_Py_Void();
52750 }
52751
52752 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52753 return SWIG_Python_InitShadowInstance(args);
52754 }
52755
52756 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52757 PyObject *resultobj = 0;
52758 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
52759 int arg2 = (int) wxHORIZONTAL ;
52760 wxStaticBoxSizer *result = 0 ;
52761 void *argp1 = 0 ;
52762 int res1 = 0 ;
52763 int val2 ;
52764 int ecode2 = 0 ;
52765 PyObject * obj0 = 0 ;
52766 PyObject * obj1 = 0 ;
52767 char * kwnames[] = {
52768 (char *) "box",(char *) "orient", NULL
52769 };
52770
52771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
52772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
52773 if (!SWIG_IsOK(res1)) {
52774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
52775 }
52776 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
52777 if (obj1) {
52778 ecode2 = SWIG_AsVal_int(obj1, &val2);
52779 if (!SWIG_IsOK(ecode2)) {
52780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
52781 }
52782 arg2 = static_cast< int >(val2);
52783 }
52784 {
52785 PyThreadState* __tstate = wxPyBeginAllowThreads();
52786 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
52787 wxPyEndAllowThreads(__tstate);
52788 if (PyErr_Occurred()) SWIG_fail;
52789 }
52790 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
52791 return resultobj;
52792 fail:
52793 return NULL;
52794 }
52795
52796
52797 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52798 PyObject *resultobj = 0;
52799 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
52800 wxStaticBox *result = 0 ;
52801 void *argp1 = 0 ;
52802 int res1 = 0 ;
52803 PyObject *swig_obj[1] ;
52804
52805 if (!args) SWIG_fail;
52806 swig_obj[0] = args;
52807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
52808 if (!SWIG_IsOK(res1)) {
52809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
52810 }
52811 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
52812 {
52813 PyThreadState* __tstate = wxPyBeginAllowThreads();
52814 result = (wxStaticBox *)(arg1)->GetStaticBox();
52815 wxPyEndAllowThreads(__tstate);
52816 if (PyErr_Occurred()) SWIG_fail;
52817 }
52818 {
52819 resultobj = wxPyMake_wxObject(result, (bool)0);
52820 }
52821 return resultobj;
52822 fail:
52823 return NULL;
52824 }
52825
52826
52827 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52828 PyObject *obj;
52829 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52830 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
52831 return SWIG_Py_Void();
52832 }
52833
52834 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52835 return SWIG_Python_InitShadowInstance(args);
52836 }
52837
52838 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52839 PyObject *resultobj = 0;
52840 int arg1 = (int) 1 ;
52841 int arg2 = (int) 0 ;
52842 int arg3 = (int) 0 ;
52843 int arg4 = (int) 0 ;
52844 wxGridSizer *result = 0 ;
52845 int val1 ;
52846 int ecode1 = 0 ;
52847 int val2 ;
52848 int ecode2 = 0 ;
52849 int val3 ;
52850 int ecode3 = 0 ;
52851 int val4 ;
52852 int ecode4 = 0 ;
52853 PyObject * obj0 = 0 ;
52854 PyObject * obj1 = 0 ;
52855 PyObject * obj2 = 0 ;
52856 PyObject * obj3 = 0 ;
52857 char * kwnames[] = {
52858 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
52859 };
52860
52861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52862 if (obj0) {
52863 ecode1 = SWIG_AsVal_int(obj0, &val1);
52864 if (!SWIG_IsOK(ecode1)) {
52865 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
52866 }
52867 arg1 = static_cast< int >(val1);
52868 }
52869 if (obj1) {
52870 ecode2 = SWIG_AsVal_int(obj1, &val2);
52871 if (!SWIG_IsOK(ecode2)) {
52872 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
52873 }
52874 arg2 = static_cast< int >(val2);
52875 }
52876 if (obj2) {
52877 ecode3 = SWIG_AsVal_int(obj2, &val3);
52878 if (!SWIG_IsOK(ecode3)) {
52879 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
52880 }
52881 arg3 = static_cast< int >(val3);
52882 }
52883 if (obj3) {
52884 ecode4 = SWIG_AsVal_int(obj3, &val4);
52885 if (!SWIG_IsOK(ecode4)) {
52886 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
52887 }
52888 arg4 = static_cast< int >(val4);
52889 }
52890 {
52891 PyThreadState* __tstate = wxPyBeginAllowThreads();
52892 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
52893 wxPyEndAllowThreads(__tstate);
52894 if (PyErr_Occurred()) SWIG_fail;
52895 }
52896 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
52897 return resultobj;
52898 fail:
52899 return NULL;
52900 }
52901
52902
52903 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52904 PyObject *resultobj = 0;
52905 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
52906 int arg2 ;
52907 void *argp1 = 0 ;
52908 int res1 = 0 ;
52909 int val2 ;
52910 int ecode2 = 0 ;
52911 PyObject * obj0 = 0 ;
52912 PyObject * obj1 = 0 ;
52913 char * kwnames[] = {
52914 (char *) "self",(char *) "cols", NULL
52915 };
52916
52917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
52918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
52919 if (!SWIG_IsOK(res1)) {
52920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
52921 }
52922 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
52923 ecode2 = SWIG_AsVal_int(obj1, &val2);
52924 if (!SWIG_IsOK(ecode2)) {
52925 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
52926 }
52927 arg2 = static_cast< int >(val2);
52928 {
52929 PyThreadState* __tstate = wxPyBeginAllowThreads();
52930 (arg1)->SetCols(arg2);
52931 wxPyEndAllowThreads(__tstate);
52932 if (PyErr_Occurred()) SWIG_fail;
52933 }
52934 resultobj = SWIG_Py_Void();
52935 return resultobj;
52936 fail:
52937 return NULL;
52938 }
52939
52940
52941 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52942 PyObject *resultobj = 0;
52943 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
52944 int arg2 ;
52945 void *argp1 = 0 ;
52946 int res1 = 0 ;
52947 int val2 ;
52948 int ecode2 = 0 ;
52949 PyObject * obj0 = 0 ;
52950 PyObject * obj1 = 0 ;
52951 char * kwnames[] = {
52952 (char *) "self",(char *) "rows", NULL
52953 };
52954
52955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
52956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
52957 if (!SWIG_IsOK(res1)) {
52958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
52959 }
52960 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
52961 ecode2 = SWIG_AsVal_int(obj1, &val2);
52962 if (!SWIG_IsOK(ecode2)) {
52963 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
52964 }
52965 arg2 = static_cast< int >(val2);
52966 {
52967 PyThreadState* __tstate = wxPyBeginAllowThreads();
52968 (arg1)->SetRows(arg2);
52969 wxPyEndAllowThreads(__tstate);
52970 if (PyErr_Occurred()) SWIG_fail;
52971 }
52972 resultobj = SWIG_Py_Void();
52973 return resultobj;
52974 fail:
52975 return NULL;
52976 }
52977
52978
52979 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52980 PyObject *resultobj = 0;
52981 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
52982 int arg2 ;
52983 void *argp1 = 0 ;
52984 int res1 = 0 ;
52985 int val2 ;
52986 int ecode2 = 0 ;
52987 PyObject * obj0 = 0 ;
52988 PyObject * obj1 = 0 ;
52989 char * kwnames[] = {
52990 (char *) "self",(char *) "gap", NULL
52991 };
52992
52993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
52994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
52995 if (!SWIG_IsOK(res1)) {
52996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
52997 }
52998 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
52999 ecode2 = SWIG_AsVal_int(obj1, &val2);
53000 if (!SWIG_IsOK(ecode2)) {
53001 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
53002 }
53003 arg2 = static_cast< int >(val2);
53004 {
53005 PyThreadState* __tstate = wxPyBeginAllowThreads();
53006 (arg1)->SetVGap(arg2);
53007 wxPyEndAllowThreads(__tstate);
53008 if (PyErr_Occurred()) SWIG_fail;
53009 }
53010 resultobj = SWIG_Py_Void();
53011 return resultobj;
53012 fail:
53013 return NULL;
53014 }
53015
53016
53017 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53018 PyObject *resultobj = 0;
53019 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53020 int arg2 ;
53021 void *argp1 = 0 ;
53022 int res1 = 0 ;
53023 int val2 ;
53024 int ecode2 = 0 ;
53025 PyObject * obj0 = 0 ;
53026 PyObject * obj1 = 0 ;
53027 char * kwnames[] = {
53028 (char *) "self",(char *) "gap", NULL
53029 };
53030
53031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
53032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53033 if (!SWIG_IsOK(res1)) {
53034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53035 }
53036 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53037 ecode2 = SWIG_AsVal_int(obj1, &val2);
53038 if (!SWIG_IsOK(ecode2)) {
53039 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
53040 }
53041 arg2 = static_cast< int >(val2);
53042 {
53043 PyThreadState* __tstate = wxPyBeginAllowThreads();
53044 (arg1)->SetHGap(arg2);
53045 wxPyEndAllowThreads(__tstate);
53046 if (PyErr_Occurred()) SWIG_fail;
53047 }
53048 resultobj = SWIG_Py_Void();
53049 return resultobj;
53050 fail:
53051 return NULL;
53052 }
53053
53054
53055 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53056 PyObject *resultobj = 0;
53057 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53058 int result;
53059 void *argp1 = 0 ;
53060 int res1 = 0 ;
53061 PyObject *swig_obj[1] ;
53062
53063 if (!args) SWIG_fail;
53064 swig_obj[0] = args;
53065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53066 if (!SWIG_IsOK(res1)) {
53067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53068 }
53069 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53070 {
53071 PyThreadState* __tstate = wxPyBeginAllowThreads();
53072 result = (int)(arg1)->GetCols();
53073 wxPyEndAllowThreads(__tstate);
53074 if (PyErr_Occurred()) SWIG_fail;
53075 }
53076 resultobj = SWIG_From_int(static_cast< int >(result));
53077 return resultobj;
53078 fail:
53079 return NULL;
53080 }
53081
53082
53083 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53084 PyObject *resultobj = 0;
53085 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53086 int result;
53087 void *argp1 = 0 ;
53088 int res1 = 0 ;
53089 PyObject *swig_obj[1] ;
53090
53091 if (!args) SWIG_fail;
53092 swig_obj[0] = args;
53093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53094 if (!SWIG_IsOK(res1)) {
53095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53096 }
53097 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53098 {
53099 PyThreadState* __tstate = wxPyBeginAllowThreads();
53100 result = (int)(arg1)->GetRows();
53101 wxPyEndAllowThreads(__tstate);
53102 if (PyErr_Occurred()) SWIG_fail;
53103 }
53104 resultobj = SWIG_From_int(static_cast< int >(result));
53105 return resultobj;
53106 fail:
53107 return NULL;
53108 }
53109
53110
53111 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53112 PyObject *resultobj = 0;
53113 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53114 int result;
53115 void *argp1 = 0 ;
53116 int res1 = 0 ;
53117 PyObject *swig_obj[1] ;
53118
53119 if (!args) SWIG_fail;
53120 swig_obj[0] = args;
53121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53122 if (!SWIG_IsOK(res1)) {
53123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53124 }
53125 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53126 {
53127 PyThreadState* __tstate = wxPyBeginAllowThreads();
53128 result = (int)(arg1)->GetVGap();
53129 wxPyEndAllowThreads(__tstate);
53130 if (PyErr_Occurred()) SWIG_fail;
53131 }
53132 resultobj = SWIG_From_int(static_cast< int >(result));
53133 return resultobj;
53134 fail:
53135 return NULL;
53136 }
53137
53138
53139 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53140 PyObject *resultobj = 0;
53141 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53142 int result;
53143 void *argp1 = 0 ;
53144 int res1 = 0 ;
53145 PyObject *swig_obj[1] ;
53146
53147 if (!args) SWIG_fail;
53148 swig_obj[0] = args;
53149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53150 if (!SWIG_IsOK(res1)) {
53151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53152 }
53153 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53154 {
53155 PyThreadState* __tstate = wxPyBeginAllowThreads();
53156 result = (int)(arg1)->GetHGap();
53157 wxPyEndAllowThreads(__tstate);
53158 if (PyErr_Occurred()) SWIG_fail;
53159 }
53160 resultobj = SWIG_From_int(static_cast< int >(result));
53161 return resultobj;
53162 fail:
53163 return NULL;
53164 }
53165
53166
53167 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53168 PyObject *obj;
53169 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53170 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
53171 return SWIG_Py_Void();
53172 }
53173
53174 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53175 return SWIG_Python_InitShadowInstance(args);
53176 }
53177
53178 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53179 PyObject *resultobj = 0;
53180 int arg1 = (int) 1 ;
53181 int arg2 = (int) 0 ;
53182 int arg3 = (int) 0 ;
53183 int arg4 = (int) 0 ;
53184 wxFlexGridSizer *result = 0 ;
53185 int val1 ;
53186 int ecode1 = 0 ;
53187 int val2 ;
53188 int ecode2 = 0 ;
53189 int val3 ;
53190 int ecode3 = 0 ;
53191 int val4 ;
53192 int ecode4 = 0 ;
53193 PyObject * obj0 = 0 ;
53194 PyObject * obj1 = 0 ;
53195 PyObject * obj2 = 0 ;
53196 PyObject * obj3 = 0 ;
53197 char * kwnames[] = {
53198 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
53199 };
53200
53201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53202 if (obj0) {
53203 ecode1 = SWIG_AsVal_int(obj0, &val1);
53204 if (!SWIG_IsOK(ecode1)) {
53205 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
53206 }
53207 arg1 = static_cast< int >(val1);
53208 }
53209 if (obj1) {
53210 ecode2 = SWIG_AsVal_int(obj1, &val2);
53211 if (!SWIG_IsOK(ecode2)) {
53212 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
53213 }
53214 arg2 = static_cast< int >(val2);
53215 }
53216 if (obj2) {
53217 ecode3 = SWIG_AsVal_int(obj2, &val3);
53218 if (!SWIG_IsOK(ecode3)) {
53219 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
53220 }
53221 arg3 = static_cast< int >(val3);
53222 }
53223 if (obj3) {
53224 ecode4 = SWIG_AsVal_int(obj3, &val4);
53225 if (!SWIG_IsOK(ecode4)) {
53226 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
53227 }
53228 arg4 = static_cast< int >(val4);
53229 }
53230 {
53231 PyThreadState* __tstate = wxPyBeginAllowThreads();
53232 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
53233 wxPyEndAllowThreads(__tstate);
53234 if (PyErr_Occurred()) SWIG_fail;
53235 }
53236 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
53237 return resultobj;
53238 fail:
53239 return NULL;
53240 }
53241
53242
53243 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53244 PyObject *resultobj = 0;
53245 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53246 size_t arg2 ;
53247 int arg3 = (int) 0 ;
53248 void *argp1 = 0 ;
53249 int res1 = 0 ;
53250 size_t val2 ;
53251 int ecode2 = 0 ;
53252 int val3 ;
53253 int ecode3 = 0 ;
53254 PyObject * obj0 = 0 ;
53255 PyObject * obj1 = 0 ;
53256 PyObject * obj2 = 0 ;
53257 char * kwnames[] = {
53258 (char *) "self",(char *) "idx",(char *) "proportion", NULL
53259 };
53260
53261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53263 if (!SWIG_IsOK(res1)) {
53264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53265 }
53266 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53267 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
53268 if (!SWIG_IsOK(ecode2)) {
53269 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
53270 }
53271 arg2 = static_cast< size_t >(val2);
53272 if (obj2) {
53273 ecode3 = SWIG_AsVal_int(obj2, &val3);
53274 if (!SWIG_IsOK(ecode3)) {
53275 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
53276 }
53277 arg3 = static_cast< int >(val3);
53278 }
53279 {
53280 PyThreadState* __tstate = wxPyBeginAllowThreads();
53281 (arg1)->AddGrowableRow(arg2,arg3);
53282 wxPyEndAllowThreads(__tstate);
53283 if (PyErr_Occurred()) SWIG_fail;
53284 }
53285 resultobj = SWIG_Py_Void();
53286 return resultobj;
53287 fail:
53288 return NULL;
53289 }
53290
53291
53292 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53293 PyObject *resultobj = 0;
53294 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53295 size_t arg2 ;
53296 void *argp1 = 0 ;
53297 int res1 = 0 ;
53298 size_t val2 ;
53299 int ecode2 = 0 ;
53300 PyObject * obj0 = 0 ;
53301 PyObject * obj1 = 0 ;
53302 char * kwnames[] = {
53303 (char *) "self",(char *) "idx", NULL
53304 };
53305
53306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
53307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53308 if (!SWIG_IsOK(res1)) {
53309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53310 }
53311 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53312 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
53313 if (!SWIG_IsOK(ecode2)) {
53314 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
53315 }
53316 arg2 = static_cast< size_t >(val2);
53317 {
53318 PyThreadState* __tstate = wxPyBeginAllowThreads();
53319 (arg1)->RemoveGrowableRow(arg2);
53320 wxPyEndAllowThreads(__tstate);
53321 if (PyErr_Occurred()) SWIG_fail;
53322 }
53323 resultobj = SWIG_Py_Void();
53324 return resultobj;
53325 fail:
53326 return NULL;
53327 }
53328
53329
53330 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53331 PyObject *resultobj = 0;
53332 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53333 size_t arg2 ;
53334 int arg3 = (int) 0 ;
53335 void *argp1 = 0 ;
53336 int res1 = 0 ;
53337 size_t val2 ;
53338 int ecode2 = 0 ;
53339 int val3 ;
53340 int ecode3 = 0 ;
53341 PyObject * obj0 = 0 ;
53342 PyObject * obj1 = 0 ;
53343 PyObject * obj2 = 0 ;
53344 char * kwnames[] = {
53345 (char *) "self",(char *) "idx",(char *) "proportion", NULL
53346 };
53347
53348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53350 if (!SWIG_IsOK(res1)) {
53351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53352 }
53353 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53354 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
53355 if (!SWIG_IsOK(ecode2)) {
53356 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
53357 }
53358 arg2 = static_cast< size_t >(val2);
53359 if (obj2) {
53360 ecode3 = SWIG_AsVal_int(obj2, &val3);
53361 if (!SWIG_IsOK(ecode3)) {
53362 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
53363 }
53364 arg3 = static_cast< int >(val3);
53365 }
53366 {
53367 PyThreadState* __tstate = wxPyBeginAllowThreads();
53368 (arg1)->AddGrowableCol(arg2,arg3);
53369 wxPyEndAllowThreads(__tstate);
53370 if (PyErr_Occurred()) SWIG_fail;
53371 }
53372 resultobj = SWIG_Py_Void();
53373 return resultobj;
53374 fail:
53375 return NULL;
53376 }
53377
53378
53379 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53380 PyObject *resultobj = 0;
53381 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53382 size_t arg2 ;
53383 void *argp1 = 0 ;
53384 int res1 = 0 ;
53385 size_t val2 ;
53386 int ecode2 = 0 ;
53387 PyObject * obj0 = 0 ;
53388 PyObject * obj1 = 0 ;
53389 char * kwnames[] = {
53390 (char *) "self",(char *) "idx", NULL
53391 };
53392
53393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
53394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53395 if (!SWIG_IsOK(res1)) {
53396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53397 }
53398 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53399 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
53400 if (!SWIG_IsOK(ecode2)) {
53401 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
53402 }
53403 arg2 = static_cast< size_t >(val2);
53404 {
53405 PyThreadState* __tstate = wxPyBeginAllowThreads();
53406 (arg1)->RemoveGrowableCol(arg2);
53407 wxPyEndAllowThreads(__tstate);
53408 if (PyErr_Occurred()) SWIG_fail;
53409 }
53410 resultobj = SWIG_Py_Void();
53411 return resultobj;
53412 fail:
53413 return NULL;
53414 }
53415
53416
53417 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53418 PyObject *resultobj = 0;
53419 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53420 int arg2 ;
53421 void *argp1 = 0 ;
53422 int res1 = 0 ;
53423 int val2 ;
53424 int ecode2 = 0 ;
53425 PyObject * obj0 = 0 ;
53426 PyObject * obj1 = 0 ;
53427 char * kwnames[] = {
53428 (char *) "self",(char *) "direction", NULL
53429 };
53430
53431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
53432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53433 if (!SWIG_IsOK(res1)) {
53434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53435 }
53436 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53437 ecode2 = SWIG_AsVal_int(obj1, &val2);
53438 if (!SWIG_IsOK(ecode2)) {
53439 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
53440 }
53441 arg2 = static_cast< int >(val2);
53442 {
53443 PyThreadState* __tstate = wxPyBeginAllowThreads();
53444 (arg1)->SetFlexibleDirection(arg2);
53445 wxPyEndAllowThreads(__tstate);
53446 if (PyErr_Occurred()) SWIG_fail;
53447 }
53448 resultobj = SWIG_Py_Void();
53449 return resultobj;
53450 fail:
53451 return NULL;
53452 }
53453
53454
53455 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53456 PyObject *resultobj = 0;
53457 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53458 int result;
53459 void *argp1 = 0 ;
53460 int res1 = 0 ;
53461 PyObject *swig_obj[1] ;
53462
53463 if (!args) SWIG_fail;
53464 swig_obj[0] = args;
53465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53466 if (!SWIG_IsOK(res1)) {
53467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53468 }
53469 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53470 {
53471 PyThreadState* __tstate = wxPyBeginAllowThreads();
53472 result = (int)(arg1)->GetFlexibleDirection();
53473 wxPyEndAllowThreads(__tstate);
53474 if (PyErr_Occurred()) SWIG_fail;
53475 }
53476 resultobj = SWIG_From_int(static_cast< int >(result));
53477 return resultobj;
53478 fail:
53479 return NULL;
53480 }
53481
53482
53483 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53484 PyObject *resultobj = 0;
53485 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53486 wxFlexSizerGrowMode arg2 ;
53487 void *argp1 = 0 ;
53488 int res1 = 0 ;
53489 int val2 ;
53490 int ecode2 = 0 ;
53491 PyObject * obj0 = 0 ;
53492 PyObject * obj1 = 0 ;
53493 char * kwnames[] = {
53494 (char *) "self",(char *) "mode", NULL
53495 };
53496
53497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
53498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53499 if (!SWIG_IsOK(res1)) {
53500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53501 }
53502 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53503 ecode2 = SWIG_AsVal_int(obj1, &val2);
53504 if (!SWIG_IsOK(ecode2)) {
53505 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
53506 }
53507 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
53508 {
53509 PyThreadState* __tstate = wxPyBeginAllowThreads();
53510 (arg1)->SetNonFlexibleGrowMode(arg2);
53511 wxPyEndAllowThreads(__tstate);
53512 if (PyErr_Occurred()) SWIG_fail;
53513 }
53514 resultobj = SWIG_Py_Void();
53515 return resultobj;
53516 fail:
53517 return NULL;
53518 }
53519
53520
53521 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53522 PyObject *resultobj = 0;
53523 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53524 wxFlexSizerGrowMode result;
53525 void *argp1 = 0 ;
53526 int res1 = 0 ;
53527 PyObject *swig_obj[1] ;
53528
53529 if (!args) SWIG_fail;
53530 swig_obj[0] = args;
53531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53532 if (!SWIG_IsOK(res1)) {
53533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53534 }
53535 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53536 {
53537 PyThreadState* __tstate = wxPyBeginAllowThreads();
53538 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
53539 wxPyEndAllowThreads(__tstate);
53540 if (PyErr_Occurred()) SWIG_fail;
53541 }
53542 resultobj = SWIG_From_int(static_cast< int >(result));
53543 return resultobj;
53544 fail:
53545 return NULL;
53546 }
53547
53548
53549 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53550 PyObject *resultobj = 0;
53551 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53552 wxArrayInt *result = 0 ;
53553 void *argp1 = 0 ;
53554 int res1 = 0 ;
53555 PyObject *swig_obj[1] ;
53556
53557 if (!args) SWIG_fail;
53558 swig_obj[0] = args;
53559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53560 if (!SWIG_IsOK(res1)) {
53561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
53562 }
53563 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53564 {
53565 PyThreadState* __tstate = wxPyBeginAllowThreads();
53566 {
53567 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
53568 result = (wxArrayInt *) &_result_ref;
53569 }
53570 wxPyEndAllowThreads(__tstate);
53571 if (PyErr_Occurred()) SWIG_fail;
53572 }
53573 {
53574 resultobj = wxArrayInt2PyList_helper(*result);
53575 }
53576 return resultobj;
53577 fail:
53578 return NULL;
53579 }
53580
53581
53582 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53583 PyObject *resultobj = 0;
53584 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53585 wxArrayInt *result = 0 ;
53586 void *argp1 = 0 ;
53587 int res1 = 0 ;
53588 PyObject *swig_obj[1] ;
53589
53590 if (!args) SWIG_fail;
53591 swig_obj[0] = args;
53592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53593 if (!SWIG_IsOK(res1)) {
53594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
53595 }
53596 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53597 {
53598 PyThreadState* __tstate = wxPyBeginAllowThreads();
53599 {
53600 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
53601 result = (wxArrayInt *) &_result_ref;
53602 }
53603 wxPyEndAllowThreads(__tstate);
53604 if (PyErr_Occurred()) SWIG_fail;
53605 }
53606 {
53607 resultobj = wxArrayInt2PyList_helper(*result);
53608 }
53609 return resultobj;
53610 fail:
53611 return NULL;
53612 }
53613
53614
53615 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53616 PyObject *obj;
53617 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53618 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
53619 return SWIG_Py_Void();
53620 }
53621
53622 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53623 return SWIG_Python_InitShadowInstance(args);
53624 }
53625
53626 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53627 PyObject *resultobj = 0;
53628 wxStdDialogButtonSizer *result = 0 ;
53629
53630 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
53631 {
53632 PyThreadState* __tstate = wxPyBeginAllowThreads();
53633 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
53634 wxPyEndAllowThreads(__tstate);
53635 if (PyErr_Occurred()) SWIG_fail;
53636 }
53637 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
53638 return resultobj;
53639 fail:
53640 return NULL;
53641 }
53642
53643
53644 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53645 PyObject *resultobj = 0;
53646 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
53647 wxButton *arg2 = (wxButton *) 0 ;
53648 void *argp1 = 0 ;
53649 int res1 = 0 ;
53650 void *argp2 = 0 ;
53651 int res2 = 0 ;
53652 PyObject * obj0 = 0 ;
53653 PyObject * obj1 = 0 ;
53654 char * kwnames[] = {
53655 (char *) "self",(char *) "button", NULL
53656 };
53657
53658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
53659 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
53660 if (!SWIG_IsOK(res1)) {
53661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
53662 }
53663 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
53664 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
53665 if (!SWIG_IsOK(res2)) {
53666 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
53667 }
53668 arg2 = reinterpret_cast< wxButton * >(argp2);
53669 {
53670 PyThreadState* __tstate = wxPyBeginAllowThreads();
53671 (arg1)->AddButton(arg2);
53672 wxPyEndAllowThreads(__tstate);
53673 if (PyErr_Occurred()) SWIG_fail;
53674 }
53675 resultobj = SWIG_Py_Void();
53676 return resultobj;
53677 fail:
53678 return NULL;
53679 }
53680
53681
53682 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53683 PyObject *resultobj = 0;
53684 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
53685 void *argp1 = 0 ;
53686 int res1 = 0 ;
53687 PyObject *swig_obj[1] ;
53688
53689 if (!args) SWIG_fail;
53690 swig_obj[0] = args;
53691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
53692 if (!SWIG_IsOK(res1)) {
53693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
53694 }
53695 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
53696 {
53697 PyThreadState* __tstate = wxPyBeginAllowThreads();
53698 (arg1)->Realize();
53699 wxPyEndAllowThreads(__tstate);
53700 if (PyErr_Occurred()) SWIG_fail;
53701 }
53702 resultobj = SWIG_Py_Void();
53703 return resultobj;
53704 fail:
53705 return NULL;
53706 }
53707
53708
53709 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53710 PyObject *resultobj = 0;
53711 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
53712 wxButton *arg2 = (wxButton *) 0 ;
53713 void *argp1 = 0 ;
53714 int res1 = 0 ;
53715 void *argp2 = 0 ;
53716 int res2 = 0 ;
53717 PyObject * obj0 = 0 ;
53718 PyObject * obj1 = 0 ;
53719 char * kwnames[] = {
53720 (char *) "self",(char *) "button", NULL
53721 };
53722
53723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
53724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
53725 if (!SWIG_IsOK(res1)) {
53726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
53727 }
53728 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
53729 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
53730 if (!SWIG_IsOK(res2)) {
53731 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
53732 }
53733 arg2 = reinterpret_cast< wxButton * >(argp2);
53734 {
53735 PyThreadState* __tstate = wxPyBeginAllowThreads();
53736 (arg1)->SetAffirmativeButton(arg2);
53737 wxPyEndAllowThreads(__tstate);
53738 if (PyErr_Occurred()) SWIG_fail;
53739 }
53740 resultobj = SWIG_Py_Void();
53741 return resultobj;
53742 fail:
53743 return NULL;
53744 }
53745
53746
53747 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53748 PyObject *resultobj = 0;
53749 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
53750 wxButton *arg2 = (wxButton *) 0 ;
53751 void *argp1 = 0 ;
53752 int res1 = 0 ;
53753 void *argp2 = 0 ;
53754 int res2 = 0 ;
53755 PyObject * obj0 = 0 ;
53756 PyObject * obj1 = 0 ;
53757 char * kwnames[] = {
53758 (char *) "self",(char *) "button", NULL
53759 };
53760
53761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
53762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
53763 if (!SWIG_IsOK(res1)) {
53764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
53765 }
53766 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
53767 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
53768 if (!SWIG_IsOK(res2)) {
53769 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
53770 }
53771 arg2 = reinterpret_cast< wxButton * >(argp2);
53772 {
53773 PyThreadState* __tstate = wxPyBeginAllowThreads();
53774 (arg1)->SetNegativeButton(arg2);
53775 wxPyEndAllowThreads(__tstate);
53776 if (PyErr_Occurred()) SWIG_fail;
53777 }
53778 resultobj = SWIG_Py_Void();
53779 return resultobj;
53780 fail:
53781 return NULL;
53782 }
53783
53784
53785 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53786 PyObject *resultobj = 0;
53787 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
53788 wxButton *arg2 = (wxButton *) 0 ;
53789 void *argp1 = 0 ;
53790 int res1 = 0 ;
53791 void *argp2 = 0 ;
53792 int res2 = 0 ;
53793 PyObject * obj0 = 0 ;
53794 PyObject * obj1 = 0 ;
53795 char * kwnames[] = {
53796 (char *) "self",(char *) "button", NULL
53797 };
53798
53799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
53800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
53801 if (!SWIG_IsOK(res1)) {
53802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
53803 }
53804 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
53805 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
53806 if (!SWIG_IsOK(res2)) {
53807 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
53808 }
53809 arg2 = reinterpret_cast< wxButton * >(argp2);
53810 {
53811 PyThreadState* __tstate = wxPyBeginAllowThreads();
53812 (arg1)->SetCancelButton(arg2);
53813 wxPyEndAllowThreads(__tstate);
53814 if (PyErr_Occurred()) SWIG_fail;
53815 }
53816 resultobj = SWIG_Py_Void();
53817 return resultobj;
53818 fail:
53819 return NULL;
53820 }
53821
53822
53823 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53824 PyObject *resultobj = 0;
53825 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
53826 wxButton *result = 0 ;
53827 void *argp1 = 0 ;
53828 int res1 = 0 ;
53829 PyObject *swig_obj[1] ;
53830
53831 if (!args) SWIG_fail;
53832 swig_obj[0] = args;
53833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
53834 if (!SWIG_IsOK(res1)) {
53835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
53836 }
53837 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
53838 {
53839 PyThreadState* __tstate = wxPyBeginAllowThreads();
53840 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
53841 wxPyEndAllowThreads(__tstate);
53842 if (PyErr_Occurred()) SWIG_fail;
53843 }
53844 {
53845 resultobj = wxPyMake_wxObject(result, (bool)0);
53846 }
53847 return resultobj;
53848 fail:
53849 return NULL;
53850 }
53851
53852
53853 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53854 PyObject *resultobj = 0;
53855 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
53856 wxButton *result = 0 ;
53857 void *argp1 = 0 ;
53858 int res1 = 0 ;
53859 PyObject *swig_obj[1] ;
53860
53861 if (!args) SWIG_fail;
53862 swig_obj[0] = args;
53863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
53864 if (!SWIG_IsOK(res1)) {
53865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
53866 }
53867 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
53868 {
53869 PyThreadState* __tstate = wxPyBeginAllowThreads();
53870 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
53871 wxPyEndAllowThreads(__tstate);
53872 if (PyErr_Occurred()) SWIG_fail;
53873 }
53874 {
53875 resultobj = wxPyMake_wxObject(result, (bool)0);
53876 }
53877 return resultobj;
53878 fail:
53879 return NULL;
53880 }
53881
53882
53883 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53884 PyObject *resultobj = 0;
53885 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
53886 wxButton *result = 0 ;
53887 void *argp1 = 0 ;
53888 int res1 = 0 ;
53889 PyObject *swig_obj[1] ;
53890
53891 if (!args) SWIG_fail;
53892 swig_obj[0] = args;
53893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
53894 if (!SWIG_IsOK(res1)) {
53895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
53896 }
53897 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
53898 {
53899 PyThreadState* __tstate = wxPyBeginAllowThreads();
53900 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
53901 wxPyEndAllowThreads(__tstate);
53902 if (PyErr_Occurred()) SWIG_fail;
53903 }
53904 {
53905 resultobj = wxPyMake_wxObject(result, (bool)0);
53906 }
53907 return resultobj;
53908 fail:
53909 return NULL;
53910 }
53911
53912
53913 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53914 PyObject *resultobj = 0;
53915 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
53916 wxButton *result = 0 ;
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_wxStdDialogButtonSizer, 0 | 0 );
53924 if (!SWIG_IsOK(res1)) {
53925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
53926 }
53927 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
53928 {
53929 PyThreadState* __tstate = wxPyBeginAllowThreads();
53930 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
53931 wxPyEndAllowThreads(__tstate);
53932 if (PyErr_Occurred()) SWIG_fail;
53933 }
53934 {
53935 resultobj = wxPyMake_wxObject(result, (bool)0);
53936 }
53937 return resultobj;
53938 fail:
53939 return NULL;
53940 }
53941
53942
53943 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53944 PyObject *resultobj = 0;
53945 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
53946 wxButton *result = 0 ;
53947 void *argp1 = 0 ;
53948 int res1 = 0 ;
53949 PyObject *swig_obj[1] ;
53950
53951 if (!args) SWIG_fail;
53952 swig_obj[0] = args;
53953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
53954 if (!SWIG_IsOK(res1)) {
53955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
53956 }
53957 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
53958 {
53959 PyThreadState* __tstate = wxPyBeginAllowThreads();
53960 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
53961 wxPyEndAllowThreads(__tstate);
53962 if (PyErr_Occurred()) SWIG_fail;
53963 }
53964 {
53965 resultobj = wxPyMake_wxObject(result, (bool)0);
53966 }
53967 return resultobj;
53968 fail:
53969 return NULL;
53970 }
53971
53972
53973 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53974 PyObject *obj;
53975 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53976 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
53977 return SWIG_Py_Void();
53978 }
53979
53980 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53981 return SWIG_Python_InitShadowInstance(args);
53982 }
53983
53984 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53985 PyObject *resultobj = 0;
53986 int arg1 = (int) 0 ;
53987 int arg2 = (int) 0 ;
53988 wxGBPosition *result = 0 ;
53989 int val1 ;
53990 int ecode1 = 0 ;
53991 int val2 ;
53992 int ecode2 = 0 ;
53993 PyObject * obj0 = 0 ;
53994 PyObject * obj1 = 0 ;
53995 char * kwnames[] = {
53996 (char *) "row",(char *) "col", NULL
53997 };
53998
53999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
54000 if (obj0) {
54001 ecode1 = SWIG_AsVal_int(obj0, &val1);
54002 if (!SWIG_IsOK(ecode1)) {
54003 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
54004 }
54005 arg1 = static_cast< int >(val1);
54006 }
54007 if (obj1) {
54008 ecode2 = SWIG_AsVal_int(obj1, &val2);
54009 if (!SWIG_IsOK(ecode2)) {
54010 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
54011 }
54012 arg2 = static_cast< int >(val2);
54013 }
54014 {
54015 PyThreadState* __tstate = wxPyBeginAllowThreads();
54016 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
54017 wxPyEndAllowThreads(__tstate);
54018 if (PyErr_Occurred()) SWIG_fail;
54019 }
54020 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
54021 return resultobj;
54022 fail:
54023 return NULL;
54024 }
54025
54026
54027 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54028 PyObject *resultobj = 0;
54029 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54030 void *argp1 = 0 ;
54031 int res1 = 0 ;
54032 PyObject *swig_obj[1] ;
54033
54034 if (!args) SWIG_fail;
54035 swig_obj[0] = args;
54036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
54037 if (!SWIG_IsOK(res1)) {
54038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54039 }
54040 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54041 {
54042 PyThreadState* __tstate = wxPyBeginAllowThreads();
54043 delete arg1;
54044
54045 wxPyEndAllowThreads(__tstate);
54046 if (PyErr_Occurred()) SWIG_fail;
54047 }
54048 resultobj = SWIG_Py_Void();
54049 return resultobj;
54050 fail:
54051 return NULL;
54052 }
54053
54054
54055 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54056 PyObject *resultobj = 0;
54057 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54058 int result;
54059 void *argp1 = 0 ;
54060 int res1 = 0 ;
54061 PyObject *swig_obj[1] ;
54062
54063 if (!args) SWIG_fail;
54064 swig_obj[0] = args;
54065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54066 if (!SWIG_IsOK(res1)) {
54067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
54068 }
54069 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54070 {
54071 PyThreadState* __tstate = wxPyBeginAllowThreads();
54072 result = (int)((wxGBPosition const *)arg1)->GetRow();
54073 wxPyEndAllowThreads(__tstate);
54074 if (PyErr_Occurred()) SWIG_fail;
54075 }
54076 resultobj = SWIG_From_int(static_cast< int >(result));
54077 return resultobj;
54078 fail:
54079 return NULL;
54080 }
54081
54082
54083 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54084 PyObject *resultobj = 0;
54085 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54086 int result;
54087 void *argp1 = 0 ;
54088 int res1 = 0 ;
54089 PyObject *swig_obj[1] ;
54090
54091 if (!args) SWIG_fail;
54092 swig_obj[0] = args;
54093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54094 if (!SWIG_IsOK(res1)) {
54095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
54096 }
54097 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54098 {
54099 PyThreadState* __tstate = wxPyBeginAllowThreads();
54100 result = (int)((wxGBPosition const *)arg1)->GetCol();
54101 wxPyEndAllowThreads(__tstate);
54102 if (PyErr_Occurred()) SWIG_fail;
54103 }
54104 resultobj = SWIG_From_int(static_cast< int >(result));
54105 return resultobj;
54106 fail:
54107 return NULL;
54108 }
54109
54110
54111 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54112 PyObject *resultobj = 0;
54113 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54114 int arg2 ;
54115 void *argp1 = 0 ;
54116 int res1 = 0 ;
54117 int val2 ;
54118 int ecode2 = 0 ;
54119 PyObject * obj0 = 0 ;
54120 PyObject * obj1 = 0 ;
54121 char * kwnames[] = {
54122 (char *) "self",(char *) "row", NULL
54123 };
54124
54125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
54126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54127 if (!SWIG_IsOK(res1)) {
54128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54129 }
54130 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54131 ecode2 = SWIG_AsVal_int(obj1, &val2);
54132 if (!SWIG_IsOK(ecode2)) {
54133 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
54134 }
54135 arg2 = static_cast< int >(val2);
54136 {
54137 PyThreadState* __tstate = wxPyBeginAllowThreads();
54138 (arg1)->SetRow(arg2);
54139 wxPyEndAllowThreads(__tstate);
54140 if (PyErr_Occurred()) SWIG_fail;
54141 }
54142 resultobj = SWIG_Py_Void();
54143 return resultobj;
54144 fail:
54145 return NULL;
54146 }
54147
54148
54149 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54150 PyObject *resultobj = 0;
54151 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54152 int arg2 ;
54153 void *argp1 = 0 ;
54154 int res1 = 0 ;
54155 int val2 ;
54156 int ecode2 = 0 ;
54157 PyObject * obj0 = 0 ;
54158 PyObject * obj1 = 0 ;
54159 char * kwnames[] = {
54160 (char *) "self",(char *) "col", NULL
54161 };
54162
54163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
54164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54165 if (!SWIG_IsOK(res1)) {
54166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54167 }
54168 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54169 ecode2 = SWIG_AsVal_int(obj1, &val2);
54170 if (!SWIG_IsOK(ecode2)) {
54171 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
54172 }
54173 arg2 = static_cast< int >(val2);
54174 {
54175 PyThreadState* __tstate = wxPyBeginAllowThreads();
54176 (arg1)->SetCol(arg2);
54177 wxPyEndAllowThreads(__tstate);
54178 if (PyErr_Occurred()) SWIG_fail;
54179 }
54180 resultobj = SWIG_Py_Void();
54181 return resultobj;
54182 fail:
54183 return NULL;
54184 }
54185
54186
54187 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54188 PyObject *resultobj = 0;
54189 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54190 PyObject *arg2 = (PyObject *) 0 ;
54191 bool result;
54192 void *argp1 = 0 ;
54193 int res1 = 0 ;
54194 PyObject * obj0 = 0 ;
54195 PyObject * obj1 = 0 ;
54196 char * kwnames[] = {
54197 (char *) "self",(char *) "other", NULL
54198 };
54199
54200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
54201 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54202 if (!SWIG_IsOK(res1)) {
54203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54204 }
54205 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54206 arg2 = obj1;
54207 {
54208 result = (bool)wxGBPosition___eq__(arg1,arg2);
54209 if (PyErr_Occurred()) SWIG_fail;
54210 }
54211 {
54212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54213 }
54214 return resultobj;
54215 fail:
54216 return NULL;
54217 }
54218
54219
54220 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54221 PyObject *resultobj = 0;
54222 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54223 PyObject *arg2 = (PyObject *) 0 ;
54224 bool result;
54225 void *argp1 = 0 ;
54226 int res1 = 0 ;
54227 PyObject * obj0 = 0 ;
54228 PyObject * obj1 = 0 ;
54229 char * kwnames[] = {
54230 (char *) "self",(char *) "other", NULL
54231 };
54232
54233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
54234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54235 if (!SWIG_IsOK(res1)) {
54236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54237 }
54238 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54239 arg2 = obj1;
54240 {
54241 result = (bool)wxGBPosition___ne__(arg1,arg2);
54242 if (PyErr_Occurred()) SWIG_fail;
54243 }
54244 {
54245 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54246 }
54247 return resultobj;
54248 fail:
54249 return NULL;
54250 }
54251
54252
54253 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54254 PyObject *resultobj = 0;
54255 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54256 int arg2 = (int) 0 ;
54257 int arg3 = (int) 0 ;
54258 void *argp1 = 0 ;
54259 int res1 = 0 ;
54260 int val2 ;
54261 int ecode2 = 0 ;
54262 int val3 ;
54263 int ecode3 = 0 ;
54264 PyObject * obj0 = 0 ;
54265 PyObject * obj1 = 0 ;
54266 PyObject * obj2 = 0 ;
54267 char * kwnames[] = {
54268 (char *) "self",(char *) "row",(char *) "col", NULL
54269 };
54270
54271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
54272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54273 if (!SWIG_IsOK(res1)) {
54274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54275 }
54276 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54277 if (obj1) {
54278 ecode2 = SWIG_AsVal_int(obj1, &val2);
54279 if (!SWIG_IsOK(ecode2)) {
54280 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
54281 }
54282 arg2 = static_cast< int >(val2);
54283 }
54284 if (obj2) {
54285 ecode3 = SWIG_AsVal_int(obj2, &val3);
54286 if (!SWIG_IsOK(ecode3)) {
54287 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
54288 }
54289 arg3 = static_cast< int >(val3);
54290 }
54291 {
54292 PyThreadState* __tstate = wxPyBeginAllowThreads();
54293 wxGBPosition_Set(arg1,arg2,arg3);
54294 wxPyEndAllowThreads(__tstate);
54295 if (PyErr_Occurred()) SWIG_fail;
54296 }
54297 resultobj = SWIG_Py_Void();
54298 return resultobj;
54299 fail:
54300 return NULL;
54301 }
54302
54303
54304 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54305 PyObject *resultobj = 0;
54306 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54307 PyObject *result = 0 ;
54308 void *argp1 = 0 ;
54309 int res1 = 0 ;
54310 PyObject *swig_obj[1] ;
54311
54312 if (!args) SWIG_fail;
54313 swig_obj[0] = args;
54314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54315 if (!SWIG_IsOK(res1)) {
54316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54317 }
54318 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54319 {
54320 PyThreadState* __tstate = wxPyBeginAllowThreads();
54321 result = (PyObject *)wxGBPosition_Get(arg1);
54322 wxPyEndAllowThreads(__tstate);
54323 if (PyErr_Occurred()) SWIG_fail;
54324 }
54325 resultobj = result;
54326 return resultobj;
54327 fail:
54328 return NULL;
54329 }
54330
54331
54332 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54333 PyObject *obj;
54334 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
54335 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
54336 return SWIG_Py_Void();
54337 }
54338
54339 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54340 return SWIG_Python_InitShadowInstance(args);
54341 }
54342
54343 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54344 PyObject *resultobj = 0;
54345 int arg1 = (int) 1 ;
54346 int arg2 = (int) 1 ;
54347 wxGBSpan *result = 0 ;
54348 int val1 ;
54349 int ecode1 = 0 ;
54350 int val2 ;
54351 int ecode2 = 0 ;
54352 PyObject * obj0 = 0 ;
54353 PyObject * obj1 = 0 ;
54354 char * kwnames[] = {
54355 (char *) "rowspan",(char *) "colspan", NULL
54356 };
54357
54358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
54359 if (obj0) {
54360 ecode1 = SWIG_AsVal_int(obj0, &val1);
54361 if (!SWIG_IsOK(ecode1)) {
54362 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
54363 }
54364 arg1 = static_cast< int >(val1);
54365 }
54366 if (obj1) {
54367 ecode2 = SWIG_AsVal_int(obj1, &val2);
54368 if (!SWIG_IsOK(ecode2)) {
54369 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
54370 }
54371 arg2 = static_cast< int >(val2);
54372 }
54373 {
54374 PyThreadState* __tstate = wxPyBeginAllowThreads();
54375 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
54376 wxPyEndAllowThreads(__tstate);
54377 if (PyErr_Occurred()) SWIG_fail;
54378 }
54379 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
54380 return resultobj;
54381 fail:
54382 return NULL;
54383 }
54384
54385
54386 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54387 PyObject *resultobj = 0;
54388 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54389 void *argp1 = 0 ;
54390 int res1 = 0 ;
54391 PyObject *swig_obj[1] ;
54392
54393 if (!args) SWIG_fail;
54394 swig_obj[0] = args;
54395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
54396 if (!SWIG_IsOK(res1)) {
54397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
54398 }
54399 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54400 {
54401 PyThreadState* __tstate = wxPyBeginAllowThreads();
54402 delete arg1;
54403
54404 wxPyEndAllowThreads(__tstate);
54405 if (PyErr_Occurred()) SWIG_fail;
54406 }
54407 resultobj = SWIG_Py_Void();
54408 return resultobj;
54409 fail:
54410 return NULL;
54411 }
54412
54413
54414 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54415 PyObject *resultobj = 0;
54416 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54417 int result;
54418 void *argp1 = 0 ;
54419 int res1 = 0 ;
54420 PyObject *swig_obj[1] ;
54421
54422 if (!args) SWIG_fail;
54423 swig_obj[0] = args;
54424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
54425 if (!SWIG_IsOK(res1)) {
54426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
54427 }
54428 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54429 {
54430 PyThreadState* __tstate = wxPyBeginAllowThreads();
54431 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
54432 wxPyEndAllowThreads(__tstate);
54433 if (PyErr_Occurred()) SWIG_fail;
54434 }
54435 resultobj = SWIG_From_int(static_cast< int >(result));
54436 return resultobj;
54437 fail:
54438 return NULL;
54439 }
54440
54441
54442 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54443 PyObject *resultobj = 0;
54444 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54445 int result;
54446 void *argp1 = 0 ;
54447 int res1 = 0 ;
54448 PyObject *swig_obj[1] ;
54449
54450 if (!args) SWIG_fail;
54451 swig_obj[0] = args;
54452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
54453 if (!SWIG_IsOK(res1)) {
54454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
54455 }
54456 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54457 {
54458 PyThreadState* __tstate = wxPyBeginAllowThreads();
54459 result = (int)((wxGBSpan const *)arg1)->GetColspan();
54460 wxPyEndAllowThreads(__tstate);
54461 if (PyErr_Occurred()) SWIG_fail;
54462 }
54463 resultobj = SWIG_From_int(static_cast< int >(result));
54464 return resultobj;
54465 fail:
54466 return NULL;
54467 }
54468
54469
54470 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54471 PyObject *resultobj = 0;
54472 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54473 int arg2 ;
54474 void *argp1 = 0 ;
54475 int res1 = 0 ;
54476 int val2 ;
54477 int ecode2 = 0 ;
54478 PyObject * obj0 = 0 ;
54479 PyObject * obj1 = 0 ;
54480 char * kwnames[] = {
54481 (char *) "self",(char *) "rowspan", NULL
54482 };
54483
54484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
54485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
54486 if (!SWIG_IsOK(res1)) {
54487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
54488 }
54489 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54490 ecode2 = SWIG_AsVal_int(obj1, &val2);
54491 if (!SWIG_IsOK(ecode2)) {
54492 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
54493 }
54494 arg2 = static_cast< int >(val2);
54495 {
54496 PyThreadState* __tstate = wxPyBeginAllowThreads();
54497 (arg1)->SetRowspan(arg2);
54498 wxPyEndAllowThreads(__tstate);
54499 if (PyErr_Occurred()) SWIG_fail;
54500 }
54501 resultobj = SWIG_Py_Void();
54502 return resultobj;
54503 fail:
54504 return NULL;
54505 }
54506
54507
54508 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54509 PyObject *resultobj = 0;
54510 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54511 int arg2 ;
54512 void *argp1 = 0 ;
54513 int res1 = 0 ;
54514 int val2 ;
54515 int ecode2 = 0 ;
54516 PyObject * obj0 = 0 ;
54517 PyObject * obj1 = 0 ;
54518 char * kwnames[] = {
54519 (char *) "self",(char *) "colspan", NULL
54520 };
54521
54522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
54523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
54524 if (!SWIG_IsOK(res1)) {
54525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
54526 }
54527 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54528 ecode2 = SWIG_AsVal_int(obj1, &val2);
54529 if (!SWIG_IsOK(ecode2)) {
54530 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
54531 }
54532 arg2 = static_cast< int >(val2);
54533 {
54534 PyThreadState* __tstate = wxPyBeginAllowThreads();
54535 (arg1)->SetColspan(arg2);
54536 wxPyEndAllowThreads(__tstate);
54537 if (PyErr_Occurred()) SWIG_fail;
54538 }
54539 resultobj = SWIG_Py_Void();
54540 return resultobj;
54541 fail:
54542 return NULL;
54543 }
54544
54545
54546 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54547 PyObject *resultobj = 0;
54548 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54549 PyObject *arg2 = (PyObject *) 0 ;
54550 bool result;
54551 void *argp1 = 0 ;
54552 int res1 = 0 ;
54553 PyObject * obj0 = 0 ;
54554 PyObject * obj1 = 0 ;
54555 char * kwnames[] = {
54556 (char *) "self",(char *) "other", NULL
54557 };
54558
54559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
54560 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
54561 if (!SWIG_IsOK(res1)) {
54562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
54563 }
54564 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54565 arg2 = obj1;
54566 {
54567 result = (bool)wxGBSpan___eq__(arg1,arg2);
54568 if (PyErr_Occurred()) SWIG_fail;
54569 }
54570 {
54571 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54572 }
54573 return resultobj;
54574 fail:
54575 return NULL;
54576 }
54577
54578
54579 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54580 PyObject *resultobj = 0;
54581 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54582 PyObject *arg2 = (PyObject *) 0 ;
54583 bool result;
54584 void *argp1 = 0 ;
54585 int res1 = 0 ;
54586 PyObject * obj0 = 0 ;
54587 PyObject * obj1 = 0 ;
54588 char * kwnames[] = {
54589 (char *) "self",(char *) "other", NULL
54590 };
54591
54592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
54593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
54594 if (!SWIG_IsOK(res1)) {
54595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
54596 }
54597 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54598 arg2 = obj1;
54599 {
54600 result = (bool)wxGBSpan___ne__(arg1,arg2);
54601 if (PyErr_Occurred()) SWIG_fail;
54602 }
54603 {
54604 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54605 }
54606 return resultobj;
54607 fail:
54608 return NULL;
54609 }
54610
54611
54612 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54613 PyObject *resultobj = 0;
54614 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54615 int arg2 = (int) 1 ;
54616 int arg3 = (int) 1 ;
54617 void *argp1 = 0 ;
54618 int res1 = 0 ;
54619 int val2 ;
54620 int ecode2 = 0 ;
54621 int val3 ;
54622 int ecode3 = 0 ;
54623 PyObject * obj0 = 0 ;
54624 PyObject * obj1 = 0 ;
54625 PyObject * obj2 = 0 ;
54626 char * kwnames[] = {
54627 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
54628 };
54629
54630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
54631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
54632 if (!SWIG_IsOK(res1)) {
54633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
54634 }
54635 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54636 if (obj1) {
54637 ecode2 = SWIG_AsVal_int(obj1, &val2);
54638 if (!SWIG_IsOK(ecode2)) {
54639 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
54640 }
54641 arg2 = static_cast< int >(val2);
54642 }
54643 if (obj2) {
54644 ecode3 = SWIG_AsVal_int(obj2, &val3);
54645 if (!SWIG_IsOK(ecode3)) {
54646 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
54647 }
54648 arg3 = static_cast< int >(val3);
54649 }
54650 {
54651 PyThreadState* __tstate = wxPyBeginAllowThreads();
54652 wxGBSpan_Set(arg1,arg2,arg3);
54653 wxPyEndAllowThreads(__tstate);
54654 if (PyErr_Occurred()) SWIG_fail;
54655 }
54656 resultobj = SWIG_Py_Void();
54657 return resultobj;
54658 fail:
54659 return NULL;
54660 }
54661
54662
54663 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54664 PyObject *resultobj = 0;
54665 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54666 PyObject *result = 0 ;
54667 void *argp1 = 0 ;
54668 int res1 = 0 ;
54669 PyObject *swig_obj[1] ;
54670
54671 if (!args) SWIG_fail;
54672 swig_obj[0] = args;
54673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
54674 if (!SWIG_IsOK(res1)) {
54675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
54676 }
54677 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54678 {
54679 PyThreadState* __tstate = wxPyBeginAllowThreads();
54680 result = (PyObject *)wxGBSpan_Get(arg1);
54681 wxPyEndAllowThreads(__tstate);
54682 if (PyErr_Occurred()) SWIG_fail;
54683 }
54684 resultobj = result;
54685 return resultobj;
54686 fail:
54687 return NULL;
54688 }
54689
54690
54691 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54692 PyObject *obj;
54693 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
54694 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
54695 return SWIG_Py_Void();
54696 }
54697
54698 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54699 return SWIG_Python_InitShadowInstance(args);
54700 }
54701
54702 SWIGINTERN int DefaultSpan_set(PyObject *) {
54703 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
54704 return 1;
54705 }
54706
54707
54708 SWIGINTERN PyObject *DefaultSpan_get(void) {
54709 PyObject *pyobj = 0;
54710
54711 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
54712 return pyobj;
54713 }
54714
54715
54716 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54717 PyObject *resultobj = 0;
54718 wxGBSizerItem *result = 0 ;
54719
54720 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
54721 {
54722 PyThreadState* __tstate = wxPyBeginAllowThreads();
54723 result = (wxGBSizerItem *)new wxGBSizerItem();
54724 wxPyEndAllowThreads(__tstate);
54725 if (PyErr_Occurred()) SWIG_fail;
54726 }
54727 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
54728 return resultobj;
54729 fail:
54730 return NULL;
54731 }
54732
54733
54734 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54735 PyObject *resultobj = 0;
54736 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
54737 void *argp1 = 0 ;
54738 int res1 = 0 ;
54739 PyObject *swig_obj[1] ;
54740
54741 if (!args) SWIG_fail;
54742 swig_obj[0] = args;
54743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
54744 if (!SWIG_IsOK(res1)) {
54745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
54746 }
54747 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
54748 {
54749 PyThreadState* __tstate = wxPyBeginAllowThreads();
54750 delete arg1;
54751
54752 wxPyEndAllowThreads(__tstate);
54753 if (PyErr_Occurred()) SWIG_fail;
54754 }
54755 resultobj = SWIG_Py_Void();
54756 return resultobj;
54757 fail:
54758 return NULL;
54759 }
54760
54761
54762 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54763 PyObject *resultobj = 0;
54764 wxWindow *arg1 = (wxWindow *) 0 ;
54765 wxGBPosition *arg2 = 0 ;
54766 wxGBSpan *arg3 = 0 ;
54767 int arg4 ;
54768 int arg5 ;
54769 PyObject *arg6 = (PyObject *) NULL ;
54770 wxGBSizerItem *result = 0 ;
54771 void *argp1 = 0 ;
54772 int res1 = 0 ;
54773 wxGBPosition temp2 ;
54774 wxGBSpan temp3 ;
54775 int val4 ;
54776 int ecode4 = 0 ;
54777 int val5 ;
54778 int ecode5 = 0 ;
54779 PyObject * obj0 = 0 ;
54780 PyObject * obj1 = 0 ;
54781 PyObject * obj2 = 0 ;
54782 PyObject * obj3 = 0 ;
54783 PyObject * obj4 = 0 ;
54784 PyObject * obj5 = 0 ;
54785 char * kwnames[] = {
54786 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
54787 };
54788
54789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
54790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
54791 if (!SWIG_IsOK(res1)) {
54792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
54793 }
54794 arg1 = reinterpret_cast< wxWindow * >(argp1);
54795 {
54796 arg2 = &temp2;
54797 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
54798 }
54799 {
54800 arg3 = &temp3;
54801 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
54802 }
54803 ecode4 = SWIG_AsVal_int(obj3, &val4);
54804 if (!SWIG_IsOK(ecode4)) {
54805 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
54806 }
54807 arg4 = static_cast< int >(val4);
54808 ecode5 = SWIG_AsVal_int(obj4, &val5);
54809 if (!SWIG_IsOK(ecode5)) {
54810 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
54811 }
54812 arg5 = static_cast< int >(val5);
54813 if (obj5) {
54814 arg6 = obj5;
54815 }
54816 {
54817 PyThreadState* __tstate = wxPyBeginAllowThreads();
54818 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
54819 wxPyEndAllowThreads(__tstate);
54820 if (PyErr_Occurred()) SWIG_fail;
54821 }
54822 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
54823 return resultobj;
54824 fail:
54825 return NULL;
54826 }
54827
54828
54829 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54830 PyObject *resultobj = 0;
54831 wxSizer *arg1 = (wxSizer *) 0 ;
54832 wxGBPosition *arg2 = 0 ;
54833 wxGBSpan *arg3 = 0 ;
54834 int arg4 ;
54835 int arg5 ;
54836 PyObject *arg6 = (PyObject *) NULL ;
54837 wxGBSizerItem *result = 0 ;
54838 int res1 = 0 ;
54839 wxGBPosition temp2 ;
54840 wxGBSpan temp3 ;
54841 int val4 ;
54842 int ecode4 = 0 ;
54843 int val5 ;
54844 int ecode5 = 0 ;
54845 PyObject * obj0 = 0 ;
54846 PyObject * obj1 = 0 ;
54847 PyObject * obj2 = 0 ;
54848 PyObject * obj3 = 0 ;
54849 PyObject * obj4 = 0 ;
54850 PyObject * obj5 = 0 ;
54851 char * kwnames[] = {
54852 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
54853 };
54854
54855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
54856 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
54857 if (!SWIG_IsOK(res1)) {
54858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
54859 }
54860 {
54861 arg2 = &temp2;
54862 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
54863 }
54864 {
54865 arg3 = &temp3;
54866 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
54867 }
54868 ecode4 = SWIG_AsVal_int(obj3, &val4);
54869 if (!SWIG_IsOK(ecode4)) {
54870 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
54871 }
54872 arg4 = static_cast< int >(val4);
54873 ecode5 = SWIG_AsVal_int(obj4, &val5);
54874 if (!SWIG_IsOK(ecode5)) {
54875 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
54876 }
54877 arg5 = static_cast< int >(val5);
54878 if (obj5) {
54879 arg6 = obj5;
54880 }
54881 {
54882 PyThreadState* __tstate = wxPyBeginAllowThreads();
54883 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
54884 wxPyEndAllowThreads(__tstate);
54885 if (PyErr_Occurred()) SWIG_fail;
54886 }
54887 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
54888 return resultobj;
54889 fail:
54890 return NULL;
54891 }
54892
54893
54894 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54895 PyObject *resultobj = 0;
54896 int arg1 ;
54897 int arg2 ;
54898 wxGBPosition *arg3 = 0 ;
54899 wxGBSpan *arg4 = 0 ;
54900 int arg5 ;
54901 int arg6 ;
54902 PyObject *arg7 = (PyObject *) NULL ;
54903 wxGBSizerItem *result = 0 ;
54904 int val1 ;
54905 int ecode1 = 0 ;
54906 int val2 ;
54907 int ecode2 = 0 ;
54908 wxGBPosition temp3 ;
54909 wxGBSpan temp4 ;
54910 int val5 ;
54911 int ecode5 = 0 ;
54912 int val6 ;
54913 int ecode6 = 0 ;
54914 PyObject * obj0 = 0 ;
54915 PyObject * obj1 = 0 ;
54916 PyObject * obj2 = 0 ;
54917 PyObject * obj3 = 0 ;
54918 PyObject * obj4 = 0 ;
54919 PyObject * obj5 = 0 ;
54920 PyObject * obj6 = 0 ;
54921 char * kwnames[] = {
54922 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
54923 };
54924
54925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
54926 ecode1 = SWIG_AsVal_int(obj0, &val1);
54927 if (!SWIG_IsOK(ecode1)) {
54928 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
54929 }
54930 arg1 = static_cast< int >(val1);
54931 ecode2 = SWIG_AsVal_int(obj1, &val2);
54932 if (!SWIG_IsOK(ecode2)) {
54933 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
54934 }
54935 arg2 = static_cast< int >(val2);
54936 {
54937 arg3 = &temp3;
54938 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
54939 }
54940 {
54941 arg4 = &temp4;
54942 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
54943 }
54944 ecode5 = SWIG_AsVal_int(obj4, &val5);
54945 if (!SWIG_IsOK(ecode5)) {
54946 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
54947 }
54948 arg5 = static_cast< int >(val5);
54949 ecode6 = SWIG_AsVal_int(obj5, &val6);
54950 if (!SWIG_IsOK(ecode6)) {
54951 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
54952 }
54953 arg6 = static_cast< int >(val6);
54954 if (obj6) {
54955 arg7 = obj6;
54956 }
54957 {
54958 PyThreadState* __tstate = wxPyBeginAllowThreads();
54959 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
54960 wxPyEndAllowThreads(__tstate);
54961 if (PyErr_Occurred()) SWIG_fail;
54962 }
54963 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
54964 return resultobj;
54965 fail:
54966 return NULL;
54967 }
54968
54969
54970 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54971 PyObject *resultobj = 0;
54972 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
54973 wxGBPosition result;
54974 void *argp1 = 0 ;
54975 int res1 = 0 ;
54976 PyObject *swig_obj[1] ;
54977
54978 if (!args) SWIG_fail;
54979 swig_obj[0] = args;
54980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54981 if (!SWIG_IsOK(res1)) {
54982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
54983 }
54984 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
54985 {
54986 PyThreadState* __tstate = wxPyBeginAllowThreads();
54987 result = ((wxGBSizerItem const *)arg1)->GetPos();
54988 wxPyEndAllowThreads(__tstate);
54989 if (PyErr_Occurred()) SWIG_fail;
54990 }
54991 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54992 return resultobj;
54993 fail:
54994 return NULL;
54995 }
54996
54997
54998 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54999 PyObject *resultobj = 0;
55000 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55001 wxGBSpan result;
55002 void *argp1 = 0 ;
55003 int res1 = 0 ;
55004 PyObject *swig_obj[1] ;
55005
55006 if (!args) SWIG_fail;
55007 swig_obj[0] = args;
55008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55009 if (!SWIG_IsOK(res1)) {
55010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
55011 }
55012 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55013 {
55014 PyThreadState* __tstate = wxPyBeginAllowThreads();
55015 result = ((wxGBSizerItem const *)arg1)->GetSpan();
55016 wxPyEndAllowThreads(__tstate);
55017 if (PyErr_Occurred()) SWIG_fail;
55018 }
55019 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
55020 return resultobj;
55021 fail:
55022 return NULL;
55023 }
55024
55025
55026 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55027 PyObject *resultobj = 0;
55028 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55029 wxGBPosition *arg2 = 0 ;
55030 bool result;
55031 void *argp1 = 0 ;
55032 int res1 = 0 ;
55033 wxGBPosition temp2 ;
55034 PyObject * obj0 = 0 ;
55035 PyObject * obj1 = 0 ;
55036 char * kwnames[] = {
55037 (char *) "self",(char *) "pos", NULL
55038 };
55039
55040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
55041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55042 if (!SWIG_IsOK(res1)) {
55043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55044 }
55045 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55046 {
55047 arg2 = &temp2;
55048 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
55049 }
55050 {
55051 PyThreadState* __tstate = wxPyBeginAllowThreads();
55052 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
55053 wxPyEndAllowThreads(__tstate);
55054 if (PyErr_Occurred()) SWIG_fail;
55055 }
55056 {
55057 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55058 }
55059 return resultobj;
55060 fail:
55061 return NULL;
55062 }
55063
55064
55065 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55066 PyObject *resultobj = 0;
55067 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55068 wxGBSpan *arg2 = 0 ;
55069 bool result;
55070 void *argp1 = 0 ;
55071 int res1 = 0 ;
55072 wxGBSpan temp2 ;
55073 PyObject * obj0 = 0 ;
55074 PyObject * obj1 = 0 ;
55075 char * kwnames[] = {
55076 (char *) "self",(char *) "span", NULL
55077 };
55078
55079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
55080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55081 if (!SWIG_IsOK(res1)) {
55082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55083 }
55084 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55085 {
55086 arg2 = &temp2;
55087 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
55088 }
55089 {
55090 PyThreadState* __tstate = wxPyBeginAllowThreads();
55091 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
55092 wxPyEndAllowThreads(__tstate);
55093 if (PyErr_Occurred()) SWIG_fail;
55094 }
55095 {
55096 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55097 }
55098 return resultobj;
55099 fail:
55100 return NULL;
55101 }
55102
55103
55104 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55105 PyObject *resultobj = 0;
55106 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55107 wxGBSizerItem *arg2 = 0 ;
55108 bool result;
55109 void *argp1 = 0 ;
55110 int res1 = 0 ;
55111 void *argp2 = 0 ;
55112 int res2 = 0 ;
55113 PyObject * obj0 = 0 ;
55114 PyObject * obj1 = 0 ;
55115 char * kwnames[] = {
55116 (char *) "self",(char *) "other", NULL
55117 };
55118
55119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
55120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55121 if (!SWIG_IsOK(res1)) {
55122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55123 }
55124 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55125 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
55126 if (!SWIG_IsOK(res2)) {
55127 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
55128 }
55129 if (!argp2) {
55130 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
55131 }
55132 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
55133 {
55134 PyThreadState* __tstate = wxPyBeginAllowThreads();
55135 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
55136 wxPyEndAllowThreads(__tstate);
55137 if (PyErr_Occurred()) SWIG_fail;
55138 }
55139 {
55140 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55141 }
55142 return resultobj;
55143 fail:
55144 return NULL;
55145 }
55146
55147
55148 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55149 PyObject *resultobj = 0;
55150 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55151 wxGBPosition *arg2 = 0 ;
55152 wxGBSpan *arg3 = 0 ;
55153 bool result;
55154 void *argp1 = 0 ;
55155 int res1 = 0 ;
55156 wxGBPosition temp2 ;
55157 wxGBSpan temp3 ;
55158 PyObject * obj0 = 0 ;
55159 PyObject * obj1 = 0 ;
55160 PyObject * obj2 = 0 ;
55161 char * kwnames[] = {
55162 (char *) "self",(char *) "pos",(char *) "span", NULL
55163 };
55164
55165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55167 if (!SWIG_IsOK(res1)) {
55168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55169 }
55170 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55171 {
55172 arg2 = &temp2;
55173 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
55174 }
55175 {
55176 arg3 = &temp3;
55177 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
55178 }
55179 {
55180 PyThreadState* __tstate = wxPyBeginAllowThreads();
55181 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
55182 wxPyEndAllowThreads(__tstate);
55183 if (PyErr_Occurred()) SWIG_fail;
55184 }
55185 {
55186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55187 }
55188 return resultobj;
55189 fail:
55190 return NULL;
55191 }
55192
55193
55194 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55195 PyObject *resultobj = 0;
55196 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55197 wxGBPosition result;
55198 void *argp1 = 0 ;
55199 int res1 = 0 ;
55200 PyObject *swig_obj[1] ;
55201
55202 if (!args) SWIG_fail;
55203 swig_obj[0] = args;
55204 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55205 if (!SWIG_IsOK(res1)) {
55206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55207 }
55208 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55209 {
55210 PyThreadState* __tstate = wxPyBeginAllowThreads();
55211 result = wxGBSizerItem_GetEndPos(arg1);
55212 wxPyEndAllowThreads(__tstate);
55213 if (PyErr_Occurred()) SWIG_fail;
55214 }
55215 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
55216 return resultobj;
55217 fail:
55218 return NULL;
55219 }
55220
55221
55222 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55223 PyObject *resultobj = 0;
55224 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55225 wxGridBagSizer *result = 0 ;
55226 void *argp1 = 0 ;
55227 int res1 = 0 ;
55228 PyObject *swig_obj[1] ;
55229
55230 if (!args) SWIG_fail;
55231 swig_obj[0] = args;
55232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55233 if (!SWIG_IsOK(res1)) {
55234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
55235 }
55236 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55237 {
55238 PyThreadState* __tstate = wxPyBeginAllowThreads();
55239 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
55240 wxPyEndAllowThreads(__tstate);
55241 if (PyErr_Occurred()) SWIG_fail;
55242 }
55243 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55244 return resultobj;
55245 fail:
55246 return NULL;
55247 }
55248
55249
55250 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55251 PyObject *resultobj = 0;
55252 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55253 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
55254 void *argp1 = 0 ;
55255 int res1 = 0 ;
55256 void *argp2 = 0 ;
55257 int res2 = 0 ;
55258 PyObject * obj0 = 0 ;
55259 PyObject * obj1 = 0 ;
55260 char * kwnames[] = {
55261 (char *) "self",(char *) "sizer", NULL
55262 };
55263
55264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
55265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55266 if (!SWIG_IsOK(res1)) {
55267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55268 }
55269 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55270 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55271 if (!SWIG_IsOK(res2)) {
55272 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
55273 }
55274 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
55275 {
55276 PyThreadState* __tstate = wxPyBeginAllowThreads();
55277 (arg1)->SetGBSizer(arg2);
55278 wxPyEndAllowThreads(__tstate);
55279 if (PyErr_Occurred()) SWIG_fail;
55280 }
55281 resultobj = SWIG_Py_Void();
55282 return resultobj;
55283 fail:
55284 return NULL;
55285 }
55286
55287
55288 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55289 PyObject *obj;
55290 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
55291 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
55292 return SWIG_Py_Void();
55293 }
55294
55295 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55296 return SWIG_Python_InitShadowInstance(args);
55297 }
55298
55299 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55300 PyObject *resultobj = 0;
55301 int arg1 = (int) 0 ;
55302 int arg2 = (int) 0 ;
55303 wxGridBagSizer *result = 0 ;
55304 int val1 ;
55305 int ecode1 = 0 ;
55306 int val2 ;
55307 int ecode2 = 0 ;
55308 PyObject * obj0 = 0 ;
55309 PyObject * obj1 = 0 ;
55310 char * kwnames[] = {
55311 (char *) "vgap",(char *) "hgap", NULL
55312 };
55313
55314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
55315 if (obj0) {
55316 ecode1 = SWIG_AsVal_int(obj0, &val1);
55317 if (!SWIG_IsOK(ecode1)) {
55318 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
55319 }
55320 arg1 = static_cast< int >(val1);
55321 }
55322 if (obj1) {
55323 ecode2 = SWIG_AsVal_int(obj1, &val2);
55324 if (!SWIG_IsOK(ecode2)) {
55325 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
55326 }
55327 arg2 = static_cast< int >(val2);
55328 }
55329 {
55330 PyThreadState* __tstate = wxPyBeginAllowThreads();
55331 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
55332 wxPyEndAllowThreads(__tstate);
55333 if (PyErr_Occurred()) SWIG_fail;
55334 }
55335 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
55336 return resultobj;
55337 fail:
55338 return NULL;
55339 }
55340
55341
55342 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55343 PyObject *resultobj = 0;
55344 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55345 PyObject *arg2 = (PyObject *) 0 ;
55346 wxGBPosition *arg3 = 0 ;
55347 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
55348 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
55349 int arg5 = (int) 0 ;
55350 int arg6 = (int) 0 ;
55351 PyObject *arg7 = (PyObject *) NULL ;
55352 wxGBSizerItem *result = 0 ;
55353 void *argp1 = 0 ;
55354 int res1 = 0 ;
55355 wxGBPosition temp3 ;
55356 wxGBSpan temp4 ;
55357 int val5 ;
55358 int ecode5 = 0 ;
55359 int val6 ;
55360 int ecode6 = 0 ;
55361 PyObject * obj0 = 0 ;
55362 PyObject * obj1 = 0 ;
55363 PyObject * obj2 = 0 ;
55364 PyObject * obj3 = 0 ;
55365 PyObject * obj4 = 0 ;
55366 PyObject * obj5 = 0 ;
55367 PyObject * obj6 = 0 ;
55368 char * kwnames[] = {
55369 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
55370 };
55371
55372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
55373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55374 if (!SWIG_IsOK(res1)) {
55375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55376 }
55377 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55378 arg2 = obj1;
55379 {
55380 arg3 = &temp3;
55381 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
55382 }
55383 if (obj3) {
55384 {
55385 arg4 = &temp4;
55386 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
55387 }
55388 }
55389 if (obj4) {
55390 ecode5 = SWIG_AsVal_int(obj4, &val5);
55391 if (!SWIG_IsOK(ecode5)) {
55392 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
55393 }
55394 arg5 = static_cast< int >(val5);
55395 }
55396 if (obj5) {
55397 ecode6 = SWIG_AsVal_int(obj5, &val6);
55398 if (!SWIG_IsOK(ecode6)) {
55399 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
55400 }
55401 arg6 = static_cast< int >(val6);
55402 }
55403 if (obj6) {
55404 arg7 = obj6;
55405 }
55406 {
55407 PyThreadState* __tstate = wxPyBeginAllowThreads();
55408 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
55409 wxPyEndAllowThreads(__tstate);
55410 if (PyErr_Occurred()) SWIG_fail;
55411 }
55412 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55413 return resultobj;
55414 fail:
55415 return NULL;
55416 }
55417
55418
55419 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55420 PyObject *resultobj = 0;
55421 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55422 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
55423 wxGBSizerItem *result = 0 ;
55424 void *argp1 = 0 ;
55425 int res1 = 0 ;
55426 int res2 = 0 ;
55427 PyObject * obj0 = 0 ;
55428 PyObject * obj1 = 0 ;
55429 char * kwnames[] = {
55430 (char *) "self",(char *) "item", NULL
55431 };
55432
55433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
55434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55435 if (!SWIG_IsOK(res1)) {
55436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55437 }
55438 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55439 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
55440 if (!SWIG_IsOK(res2)) {
55441 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
55442 }
55443 {
55444 PyThreadState* __tstate = wxPyBeginAllowThreads();
55445 result = (wxGBSizerItem *)(arg1)->Add(arg2);
55446 wxPyEndAllowThreads(__tstate);
55447 if (PyErr_Occurred()) SWIG_fail;
55448 }
55449 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55450 return resultobj;
55451 fail:
55452 return NULL;
55453 }
55454
55455
55456 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55457 PyObject *resultobj = 0;
55458 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55459 int arg2 ;
55460 int arg3 ;
55461 wxSize result;
55462 void *argp1 = 0 ;
55463 int res1 = 0 ;
55464 int val2 ;
55465 int ecode2 = 0 ;
55466 int val3 ;
55467 int ecode3 = 0 ;
55468 PyObject * obj0 = 0 ;
55469 PyObject * obj1 = 0 ;
55470 PyObject * obj2 = 0 ;
55471 char * kwnames[] = {
55472 (char *) "self",(char *) "row",(char *) "col", NULL
55473 };
55474
55475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55477 if (!SWIG_IsOK(res1)) {
55478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
55479 }
55480 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55481 ecode2 = SWIG_AsVal_int(obj1, &val2);
55482 if (!SWIG_IsOK(ecode2)) {
55483 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
55484 }
55485 arg2 = static_cast< int >(val2);
55486 ecode3 = SWIG_AsVal_int(obj2, &val3);
55487 if (!SWIG_IsOK(ecode3)) {
55488 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
55489 }
55490 arg3 = static_cast< int >(val3);
55491 {
55492 PyThreadState* __tstate = wxPyBeginAllowThreads();
55493 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
55494 wxPyEndAllowThreads(__tstate);
55495 if (PyErr_Occurred()) SWIG_fail;
55496 }
55497 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
55498 return resultobj;
55499 fail:
55500 return NULL;
55501 }
55502
55503
55504 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55505 PyObject *resultobj = 0;
55506 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55507 wxSize result;
55508 void *argp1 = 0 ;
55509 int res1 = 0 ;
55510 PyObject *swig_obj[1] ;
55511
55512 if (!args) SWIG_fail;
55513 swig_obj[0] = args;
55514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55515 if (!SWIG_IsOK(res1)) {
55516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
55517 }
55518 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55519 {
55520 PyThreadState* __tstate = wxPyBeginAllowThreads();
55521 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
55522 wxPyEndAllowThreads(__tstate);
55523 if (PyErr_Occurred()) SWIG_fail;
55524 }
55525 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
55526 return resultobj;
55527 fail:
55528 return NULL;
55529 }
55530
55531
55532 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55533 PyObject *resultobj = 0;
55534 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55535 wxSize *arg2 = 0 ;
55536 void *argp1 = 0 ;
55537 int res1 = 0 ;
55538 wxSize temp2 ;
55539 PyObject * obj0 = 0 ;
55540 PyObject * obj1 = 0 ;
55541 char * kwnames[] = {
55542 (char *) "self",(char *) "sz", NULL
55543 };
55544
55545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
55546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55547 if (!SWIG_IsOK(res1)) {
55548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55549 }
55550 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55551 {
55552 arg2 = &temp2;
55553 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
55554 }
55555 {
55556 PyThreadState* __tstate = wxPyBeginAllowThreads();
55557 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
55558 wxPyEndAllowThreads(__tstate);
55559 if (PyErr_Occurred()) SWIG_fail;
55560 }
55561 resultobj = SWIG_Py_Void();
55562 return resultobj;
55563 fail:
55564 return NULL;
55565 }
55566
55567
55568 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55569 PyObject *resultobj = 0;
55570 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55571 wxWindow *arg2 = (wxWindow *) 0 ;
55572 wxGBPosition result;
55573 void *argp1 = 0 ;
55574 int res1 = 0 ;
55575 void *argp2 = 0 ;
55576 int res2 = 0 ;
55577
55578 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
55579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55580 if (!SWIG_IsOK(res1)) {
55581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55582 }
55583 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55584 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55585 if (!SWIG_IsOK(res2)) {
55586 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
55587 }
55588 arg2 = reinterpret_cast< wxWindow * >(argp2);
55589 {
55590 PyThreadState* __tstate = wxPyBeginAllowThreads();
55591 result = (arg1)->GetItemPosition(arg2);
55592 wxPyEndAllowThreads(__tstate);
55593 if (PyErr_Occurred()) SWIG_fail;
55594 }
55595 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
55596 return resultobj;
55597 fail:
55598 return NULL;
55599 }
55600
55601
55602 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55603 PyObject *resultobj = 0;
55604 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55605 wxSizer *arg2 = (wxSizer *) 0 ;
55606 wxGBPosition result;
55607 void *argp1 = 0 ;
55608 int res1 = 0 ;
55609 void *argp2 = 0 ;
55610 int res2 = 0 ;
55611
55612 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
55613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55614 if (!SWIG_IsOK(res1)) {
55615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55616 }
55617 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55618 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
55619 if (!SWIG_IsOK(res2)) {
55620 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
55621 }
55622 arg2 = reinterpret_cast< wxSizer * >(argp2);
55623 {
55624 PyThreadState* __tstate = wxPyBeginAllowThreads();
55625 result = (arg1)->GetItemPosition(arg2);
55626 wxPyEndAllowThreads(__tstate);
55627 if (PyErr_Occurred()) SWIG_fail;
55628 }
55629 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
55630 return resultobj;
55631 fail:
55632 return NULL;
55633 }
55634
55635
55636 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55637 PyObject *resultobj = 0;
55638 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55639 size_t arg2 ;
55640 wxGBPosition result;
55641 void *argp1 = 0 ;
55642 int res1 = 0 ;
55643 size_t val2 ;
55644 int ecode2 = 0 ;
55645
55646 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
55647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55648 if (!SWIG_IsOK(res1)) {
55649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55650 }
55651 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55652 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
55653 if (!SWIG_IsOK(ecode2)) {
55654 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
55655 }
55656 arg2 = static_cast< size_t >(val2);
55657 {
55658 PyThreadState* __tstate = wxPyBeginAllowThreads();
55659 result = (arg1)->GetItemPosition(arg2);
55660 wxPyEndAllowThreads(__tstate);
55661 if (PyErr_Occurred()) SWIG_fail;
55662 }
55663 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
55664 return resultobj;
55665 fail:
55666 return NULL;
55667 }
55668
55669
55670 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
55671 int argc;
55672 PyObject *argv[3];
55673
55674 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
55675 --argc;
55676 if (argc == 2) {
55677 int _v = 0;
55678 {
55679 void *vptr = 0;
55680 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
55681 _v = SWIG_CheckState(res);
55682 }
55683 if (!_v) goto check_1;
55684 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
55685 }
55686 check_1:
55687
55688 if (argc == 2) {
55689 int _v = 0;
55690 {
55691 void *vptr = 0;
55692 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
55693 _v = SWIG_CheckState(res);
55694 }
55695 if (!_v) goto check_2;
55696 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
55697 }
55698 check_2:
55699
55700 if (argc == 2) {
55701 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
55702 }
55703
55704 fail:
55705 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
55706 return NULL;
55707 }
55708
55709
55710 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55711 PyObject *resultobj = 0;
55712 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55713 wxWindow *arg2 = (wxWindow *) 0 ;
55714 wxGBPosition *arg3 = 0 ;
55715 bool result;
55716 void *argp1 = 0 ;
55717 int res1 = 0 ;
55718 void *argp2 = 0 ;
55719 int res2 = 0 ;
55720 wxGBPosition temp3 ;
55721
55722 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
55723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55724 if (!SWIG_IsOK(res1)) {
55725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55726 }
55727 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55728 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55729 if (!SWIG_IsOK(res2)) {
55730 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
55731 }
55732 arg2 = reinterpret_cast< wxWindow * >(argp2);
55733 {
55734 arg3 = &temp3;
55735 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
55736 }
55737 {
55738 PyThreadState* __tstate = wxPyBeginAllowThreads();
55739 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
55740 wxPyEndAllowThreads(__tstate);
55741 if (PyErr_Occurred()) SWIG_fail;
55742 }
55743 {
55744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55745 }
55746 return resultobj;
55747 fail:
55748 return NULL;
55749 }
55750
55751
55752 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55753 PyObject *resultobj = 0;
55754 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55755 wxSizer *arg2 = (wxSizer *) 0 ;
55756 wxGBPosition *arg3 = 0 ;
55757 bool result;
55758 void *argp1 = 0 ;
55759 int res1 = 0 ;
55760 void *argp2 = 0 ;
55761 int res2 = 0 ;
55762 wxGBPosition temp3 ;
55763
55764 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
55765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55766 if (!SWIG_IsOK(res1)) {
55767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55768 }
55769 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55770 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
55771 if (!SWIG_IsOK(res2)) {
55772 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
55773 }
55774 arg2 = reinterpret_cast< wxSizer * >(argp2);
55775 {
55776 arg3 = &temp3;
55777 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
55778 }
55779 {
55780 PyThreadState* __tstate = wxPyBeginAllowThreads();
55781 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
55782 wxPyEndAllowThreads(__tstate);
55783 if (PyErr_Occurred()) SWIG_fail;
55784 }
55785 {
55786 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55787 }
55788 return resultobj;
55789 fail:
55790 return NULL;
55791 }
55792
55793
55794 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55795 PyObject *resultobj = 0;
55796 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55797 size_t arg2 ;
55798 wxGBPosition *arg3 = 0 ;
55799 bool result;
55800 void *argp1 = 0 ;
55801 int res1 = 0 ;
55802 size_t val2 ;
55803 int ecode2 = 0 ;
55804 wxGBPosition temp3 ;
55805
55806 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
55807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55808 if (!SWIG_IsOK(res1)) {
55809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55810 }
55811 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55812 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
55813 if (!SWIG_IsOK(ecode2)) {
55814 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
55815 }
55816 arg2 = static_cast< size_t >(val2);
55817 {
55818 arg3 = &temp3;
55819 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
55820 }
55821 {
55822 PyThreadState* __tstate = wxPyBeginAllowThreads();
55823 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
55824 wxPyEndAllowThreads(__tstate);
55825 if (PyErr_Occurred()) SWIG_fail;
55826 }
55827 {
55828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55829 }
55830 return resultobj;
55831 fail:
55832 return NULL;
55833 }
55834
55835
55836 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
55837 int argc;
55838 PyObject *argv[4];
55839
55840 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
55841 --argc;
55842 if (argc == 3) {
55843 int _v = 0;
55844 {
55845 void *vptr = 0;
55846 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
55847 _v = SWIG_CheckState(res);
55848 }
55849 if (!_v) goto check_1;
55850 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
55851 }
55852 check_1:
55853
55854 if (argc == 3) {
55855 int _v = 0;
55856 {
55857 void *vptr = 0;
55858 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
55859 _v = SWIG_CheckState(res);
55860 }
55861 if (!_v) goto check_2;
55862 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
55863 }
55864 check_2:
55865
55866 if (argc == 3) {
55867 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
55868 }
55869
55870 fail:
55871 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
55872 return NULL;
55873 }
55874
55875
55876 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55877 PyObject *resultobj = 0;
55878 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55879 wxWindow *arg2 = (wxWindow *) 0 ;
55880 wxGBSpan result;
55881 void *argp1 = 0 ;
55882 int res1 = 0 ;
55883 void *argp2 = 0 ;
55884 int res2 = 0 ;
55885
55886 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
55887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55888 if (!SWIG_IsOK(res1)) {
55889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55890 }
55891 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55892 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55893 if (!SWIG_IsOK(res2)) {
55894 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
55895 }
55896 arg2 = reinterpret_cast< wxWindow * >(argp2);
55897 {
55898 PyThreadState* __tstate = wxPyBeginAllowThreads();
55899 result = (arg1)->GetItemSpan(arg2);
55900 wxPyEndAllowThreads(__tstate);
55901 if (PyErr_Occurred()) SWIG_fail;
55902 }
55903 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
55904 return resultobj;
55905 fail:
55906 return NULL;
55907 }
55908
55909
55910 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55911 PyObject *resultobj = 0;
55912 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55913 wxSizer *arg2 = (wxSizer *) 0 ;
55914 wxGBSpan result;
55915 void *argp1 = 0 ;
55916 int res1 = 0 ;
55917 void *argp2 = 0 ;
55918 int res2 = 0 ;
55919
55920 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
55921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55922 if (!SWIG_IsOK(res1)) {
55923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55924 }
55925 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55926 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
55927 if (!SWIG_IsOK(res2)) {
55928 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
55929 }
55930 arg2 = reinterpret_cast< wxSizer * >(argp2);
55931 {
55932 PyThreadState* __tstate = wxPyBeginAllowThreads();
55933 result = (arg1)->GetItemSpan(arg2);
55934 wxPyEndAllowThreads(__tstate);
55935 if (PyErr_Occurred()) SWIG_fail;
55936 }
55937 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
55938 return resultobj;
55939 fail:
55940 return NULL;
55941 }
55942
55943
55944 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55945 PyObject *resultobj = 0;
55946 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55947 size_t arg2 ;
55948 wxGBSpan result;
55949 void *argp1 = 0 ;
55950 int res1 = 0 ;
55951 size_t val2 ;
55952 int ecode2 = 0 ;
55953
55954 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
55955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55956 if (!SWIG_IsOK(res1)) {
55957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55958 }
55959 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55960 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
55961 if (!SWIG_IsOK(ecode2)) {
55962 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
55963 }
55964 arg2 = static_cast< size_t >(val2);
55965 {
55966 PyThreadState* __tstate = wxPyBeginAllowThreads();
55967 result = (arg1)->GetItemSpan(arg2);
55968 wxPyEndAllowThreads(__tstate);
55969 if (PyErr_Occurred()) SWIG_fail;
55970 }
55971 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
55972 return resultobj;
55973 fail:
55974 return NULL;
55975 }
55976
55977
55978 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
55979 int argc;
55980 PyObject *argv[3];
55981
55982 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
55983 --argc;
55984 if (argc == 2) {
55985 int _v = 0;
55986 {
55987 void *vptr = 0;
55988 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
55989 _v = SWIG_CheckState(res);
55990 }
55991 if (!_v) goto check_1;
55992 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
55993 }
55994 check_1:
55995
55996 if (argc == 2) {
55997 int _v = 0;
55998 {
55999 void *vptr = 0;
56000 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
56001 _v = SWIG_CheckState(res);
56002 }
56003 if (!_v) goto check_2;
56004 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
56005 }
56006 check_2:
56007
56008 if (argc == 2) {
56009 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
56010 }
56011
56012 fail:
56013 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
56014 return NULL;
56015 }
56016
56017
56018 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56019 PyObject *resultobj = 0;
56020 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56021 wxWindow *arg2 = (wxWindow *) 0 ;
56022 wxGBSpan *arg3 = 0 ;
56023 bool result;
56024 void *argp1 = 0 ;
56025 int res1 = 0 ;
56026 void *argp2 = 0 ;
56027 int res2 = 0 ;
56028 wxGBSpan temp3 ;
56029
56030 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
56031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56032 if (!SWIG_IsOK(res1)) {
56033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56034 }
56035 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56036 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56037 if (!SWIG_IsOK(res2)) {
56038 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
56039 }
56040 arg2 = reinterpret_cast< wxWindow * >(argp2);
56041 {
56042 arg3 = &temp3;
56043 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
56044 }
56045 {
56046 PyThreadState* __tstate = wxPyBeginAllowThreads();
56047 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
56048 wxPyEndAllowThreads(__tstate);
56049 if (PyErr_Occurred()) SWIG_fail;
56050 }
56051 {
56052 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56053 }
56054 return resultobj;
56055 fail:
56056 return NULL;
56057 }
56058
56059
56060 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56061 PyObject *resultobj = 0;
56062 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56063 wxSizer *arg2 = (wxSizer *) 0 ;
56064 wxGBSpan *arg3 = 0 ;
56065 bool result;
56066 void *argp1 = 0 ;
56067 int res1 = 0 ;
56068 void *argp2 = 0 ;
56069 int res2 = 0 ;
56070 wxGBSpan temp3 ;
56071
56072 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
56073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56074 if (!SWIG_IsOK(res1)) {
56075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56076 }
56077 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56078 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
56079 if (!SWIG_IsOK(res2)) {
56080 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
56081 }
56082 arg2 = reinterpret_cast< wxSizer * >(argp2);
56083 {
56084 arg3 = &temp3;
56085 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
56086 }
56087 {
56088 PyThreadState* __tstate = wxPyBeginAllowThreads();
56089 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
56090 wxPyEndAllowThreads(__tstate);
56091 if (PyErr_Occurred()) SWIG_fail;
56092 }
56093 {
56094 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56095 }
56096 return resultobj;
56097 fail:
56098 return NULL;
56099 }
56100
56101
56102 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56103 PyObject *resultobj = 0;
56104 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56105 size_t arg2 ;
56106 wxGBSpan *arg3 = 0 ;
56107 bool result;
56108 void *argp1 = 0 ;
56109 int res1 = 0 ;
56110 size_t val2 ;
56111 int ecode2 = 0 ;
56112 wxGBSpan temp3 ;
56113
56114 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
56115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56116 if (!SWIG_IsOK(res1)) {
56117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56118 }
56119 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56120 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
56121 if (!SWIG_IsOK(ecode2)) {
56122 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
56123 }
56124 arg2 = static_cast< size_t >(val2);
56125 {
56126 arg3 = &temp3;
56127 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
56128 }
56129 {
56130 PyThreadState* __tstate = wxPyBeginAllowThreads();
56131 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
56132 wxPyEndAllowThreads(__tstate);
56133 if (PyErr_Occurred()) SWIG_fail;
56134 }
56135 {
56136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56137 }
56138 return resultobj;
56139 fail:
56140 return NULL;
56141 }
56142
56143
56144 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
56145 int argc;
56146 PyObject *argv[4];
56147
56148 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
56149 --argc;
56150 if (argc == 3) {
56151 int _v = 0;
56152 {
56153 void *vptr = 0;
56154 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
56155 _v = SWIG_CheckState(res);
56156 }
56157 if (!_v) goto check_1;
56158 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
56159 }
56160 check_1:
56161
56162 if (argc == 3) {
56163 int _v = 0;
56164 {
56165 void *vptr = 0;
56166 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
56167 _v = SWIG_CheckState(res);
56168 }
56169 if (!_v) goto check_2;
56170 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
56171 }
56172 check_2:
56173
56174 if (argc == 3) {
56175 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
56176 }
56177
56178 fail:
56179 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
56180 return NULL;
56181 }
56182
56183
56184 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56185 PyObject *resultobj = 0;
56186 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56187 wxWindow *arg2 = (wxWindow *) 0 ;
56188 wxGBSizerItem *result = 0 ;
56189 void *argp1 = 0 ;
56190 int res1 = 0 ;
56191 void *argp2 = 0 ;
56192 int res2 = 0 ;
56193
56194 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
56195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56196 if (!SWIG_IsOK(res1)) {
56197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56198 }
56199 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56200 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56201 if (!SWIG_IsOK(res2)) {
56202 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
56203 }
56204 arg2 = reinterpret_cast< wxWindow * >(argp2);
56205 {
56206 PyThreadState* __tstate = wxPyBeginAllowThreads();
56207 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
56208 wxPyEndAllowThreads(__tstate);
56209 if (PyErr_Occurred()) SWIG_fail;
56210 }
56211 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56212 return resultobj;
56213 fail:
56214 return NULL;
56215 }
56216
56217
56218 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56219 PyObject *resultobj = 0;
56220 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56221 wxSizer *arg2 = (wxSizer *) 0 ;
56222 wxGBSizerItem *result = 0 ;
56223 void *argp1 = 0 ;
56224 int res1 = 0 ;
56225 void *argp2 = 0 ;
56226 int res2 = 0 ;
56227
56228 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
56229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56230 if (!SWIG_IsOK(res1)) {
56231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56232 }
56233 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56234 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
56235 if (!SWIG_IsOK(res2)) {
56236 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
56237 }
56238 arg2 = reinterpret_cast< wxSizer * >(argp2);
56239 {
56240 PyThreadState* __tstate = wxPyBeginAllowThreads();
56241 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
56242 wxPyEndAllowThreads(__tstate);
56243 if (PyErr_Occurred()) SWIG_fail;
56244 }
56245 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56246 return resultobj;
56247 fail:
56248 return NULL;
56249 }
56250
56251
56252 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
56253 int argc;
56254 PyObject *argv[3];
56255
56256 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
56257 --argc;
56258 if (argc == 2) {
56259 int _v = 0;
56260 {
56261 void *vptr = 0;
56262 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
56263 _v = SWIG_CheckState(res);
56264 }
56265 if (!_v) goto check_1;
56266 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
56267 }
56268 check_1:
56269
56270 if (argc == 2) {
56271 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
56272 }
56273
56274 fail:
56275 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
56276 return NULL;
56277 }
56278
56279
56280 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56281 PyObject *resultobj = 0;
56282 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56283 wxGBPosition *arg2 = 0 ;
56284 wxGBSizerItem *result = 0 ;
56285 void *argp1 = 0 ;
56286 int res1 = 0 ;
56287 wxGBPosition temp2 ;
56288 PyObject * obj0 = 0 ;
56289 PyObject * obj1 = 0 ;
56290 char * kwnames[] = {
56291 (char *) "self",(char *) "pos", NULL
56292 };
56293
56294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
56295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56296 if (!SWIG_IsOK(res1)) {
56297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56298 }
56299 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56300 {
56301 arg2 = &temp2;
56302 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
56303 }
56304 {
56305 PyThreadState* __tstate = wxPyBeginAllowThreads();
56306 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
56307 wxPyEndAllowThreads(__tstate);
56308 if (PyErr_Occurred()) SWIG_fail;
56309 }
56310 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56311 return resultobj;
56312 fail:
56313 return NULL;
56314 }
56315
56316
56317 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56318 PyObject *resultobj = 0;
56319 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56320 wxPoint *arg2 = 0 ;
56321 wxGBSizerItem *result = 0 ;
56322 void *argp1 = 0 ;
56323 int res1 = 0 ;
56324 wxPoint temp2 ;
56325 PyObject * obj0 = 0 ;
56326 PyObject * obj1 = 0 ;
56327 char * kwnames[] = {
56328 (char *) "self",(char *) "pt", NULL
56329 };
56330
56331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
56332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56333 if (!SWIG_IsOK(res1)) {
56334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56335 }
56336 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56337 {
56338 arg2 = &temp2;
56339 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
56340 }
56341 {
56342 PyThreadState* __tstate = wxPyBeginAllowThreads();
56343 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
56344 wxPyEndAllowThreads(__tstate);
56345 if (PyErr_Occurred()) SWIG_fail;
56346 }
56347 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56348 return resultobj;
56349 fail:
56350 return NULL;
56351 }
56352
56353
56354 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56355 PyObject *resultobj = 0;
56356 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56357 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
56358 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
56359 bool result;
56360 void *argp1 = 0 ;
56361 int res1 = 0 ;
56362 void *argp2 = 0 ;
56363 int res2 = 0 ;
56364 void *argp3 = 0 ;
56365 int res3 = 0 ;
56366 PyObject * obj0 = 0 ;
56367 PyObject * obj1 = 0 ;
56368 PyObject * obj2 = 0 ;
56369 char * kwnames[] = {
56370 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
56371 };
56372
56373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
56374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56375 if (!SWIG_IsOK(res1)) {
56376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56377 }
56378 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56379 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56380 if (!SWIG_IsOK(res2)) {
56381 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
56382 }
56383 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
56384 if (obj2) {
56385 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56386 if (!SWIG_IsOK(res3)) {
56387 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
56388 }
56389 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
56390 }
56391 {
56392 PyThreadState* __tstate = wxPyBeginAllowThreads();
56393 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
56394 wxPyEndAllowThreads(__tstate);
56395 if (PyErr_Occurred()) SWIG_fail;
56396 }
56397 {
56398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56399 }
56400 return resultobj;
56401 fail:
56402 return NULL;
56403 }
56404
56405
56406 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56407 PyObject *resultobj = 0;
56408 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56409 wxGBPosition *arg2 = 0 ;
56410 wxGBSpan *arg3 = 0 ;
56411 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
56412 bool result;
56413 void *argp1 = 0 ;
56414 int res1 = 0 ;
56415 wxGBPosition temp2 ;
56416 wxGBSpan temp3 ;
56417 void *argp4 = 0 ;
56418 int res4 = 0 ;
56419 PyObject * obj0 = 0 ;
56420 PyObject * obj1 = 0 ;
56421 PyObject * obj2 = 0 ;
56422 PyObject * obj3 = 0 ;
56423 char * kwnames[] = {
56424 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
56425 };
56426
56427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
56428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56429 if (!SWIG_IsOK(res1)) {
56430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56431 }
56432 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56433 {
56434 arg2 = &temp2;
56435 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
56436 }
56437 {
56438 arg3 = &temp3;
56439 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
56440 }
56441 if (obj3) {
56442 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56443 if (!SWIG_IsOK(res4)) {
56444 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
56445 }
56446 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
56447 }
56448 {
56449 PyThreadState* __tstate = wxPyBeginAllowThreads();
56450 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
56451 wxPyEndAllowThreads(__tstate);
56452 if (PyErr_Occurred()) SWIG_fail;
56453 }
56454 {
56455 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56456 }
56457 return resultobj;
56458 fail:
56459 return NULL;
56460 }
56461
56462
56463 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56464 PyObject *obj;
56465 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
56466 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
56467 return SWIG_Py_Void();
56468 }
56469
56470 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56471 return SWIG_Python_InitShadowInstance(args);
56472 }
56473
56474 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56475 PyObject *resultobj = 0;
56476 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56477 wxRelationship arg2 ;
56478 wxWindow *arg3 = (wxWindow *) 0 ;
56479 wxEdge arg4 ;
56480 int arg5 = (int) 0 ;
56481 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
56482 void *argp1 = 0 ;
56483 int res1 = 0 ;
56484 int val2 ;
56485 int ecode2 = 0 ;
56486 void *argp3 = 0 ;
56487 int res3 = 0 ;
56488 int val4 ;
56489 int ecode4 = 0 ;
56490 int val5 ;
56491 int ecode5 = 0 ;
56492 int val6 ;
56493 int ecode6 = 0 ;
56494 PyObject * obj0 = 0 ;
56495 PyObject * obj1 = 0 ;
56496 PyObject * obj2 = 0 ;
56497 PyObject * obj3 = 0 ;
56498 PyObject * obj4 = 0 ;
56499 PyObject * obj5 = 0 ;
56500 char * kwnames[] = {
56501 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
56502 };
56503
56504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
56505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56506 if (!SWIG_IsOK(res1)) {
56507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56508 }
56509 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56510 ecode2 = SWIG_AsVal_int(obj1, &val2);
56511 if (!SWIG_IsOK(ecode2)) {
56512 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
56513 }
56514 arg2 = static_cast< wxRelationship >(val2);
56515 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
56516 if (!SWIG_IsOK(res3)) {
56517 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
56518 }
56519 arg3 = reinterpret_cast< wxWindow * >(argp3);
56520 ecode4 = SWIG_AsVal_int(obj3, &val4);
56521 if (!SWIG_IsOK(ecode4)) {
56522 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
56523 }
56524 arg4 = static_cast< wxEdge >(val4);
56525 if (obj4) {
56526 ecode5 = SWIG_AsVal_int(obj4, &val5);
56527 if (!SWIG_IsOK(ecode5)) {
56528 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
56529 }
56530 arg5 = static_cast< int >(val5);
56531 }
56532 if (obj5) {
56533 ecode6 = SWIG_AsVal_int(obj5, &val6);
56534 if (!SWIG_IsOK(ecode6)) {
56535 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
56536 }
56537 arg6 = static_cast< int >(val6);
56538 }
56539 {
56540 PyThreadState* __tstate = wxPyBeginAllowThreads();
56541 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
56542 wxPyEndAllowThreads(__tstate);
56543 if (PyErr_Occurred()) SWIG_fail;
56544 }
56545 resultobj = SWIG_Py_Void();
56546 return resultobj;
56547 fail:
56548 return NULL;
56549 }
56550
56551
56552 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56553 PyObject *resultobj = 0;
56554 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56555 wxWindow *arg2 = (wxWindow *) 0 ;
56556 int arg3 = (int) 0 ;
56557 void *argp1 = 0 ;
56558 int res1 = 0 ;
56559 void *argp2 = 0 ;
56560 int res2 = 0 ;
56561 int val3 ;
56562 int ecode3 = 0 ;
56563 PyObject * obj0 = 0 ;
56564 PyObject * obj1 = 0 ;
56565 PyObject * obj2 = 0 ;
56566 char * kwnames[] = {
56567 (char *) "self",(char *) "sibling",(char *) "marg", NULL
56568 };
56569
56570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
56571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56572 if (!SWIG_IsOK(res1)) {
56573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56574 }
56575 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56576 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56577 if (!SWIG_IsOK(res2)) {
56578 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
56579 }
56580 arg2 = reinterpret_cast< wxWindow * >(argp2);
56581 if (obj2) {
56582 ecode3 = SWIG_AsVal_int(obj2, &val3);
56583 if (!SWIG_IsOK(ecode3)) {
56584 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
56585 }
56586 arg3 = static_cast< int >(val3);
56587 }
56588 {
56589 PyThreadState* __tstate = wxPyBeginAllowThreads();
56590 (arg1)->LeftOf(arg2,arg3);
56591 wxPyEndAllowThreads(__tstate);
56592 if (PyErr_Occurred()) SWIG_fail;
56593 }
56594 resultobj = SWIG_Py_Void();
56595 return resultobj;
56596 fail:
56597 return NULL;
56598 }
56599
56600
56601 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56602 PyObject *resultobj = 0;
56603 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56604 wxWindow *arg2 = (wxWindow *) 0 ;
56605 int arg3 = (int) 0 ;
56606 void *argp1 = 0 ;
56607 int res1 = 0 ;
56608 void *argp2 = 0 ;
56609 int res2 = 0 ;
56610 int val3 ;
56611 int ecode3 = 0 ;
56612 PyObject * obj0 = 0 ;
56613 PyObject * obj1 = 0 ;
56614 PyObject * obj2 = 0 ;
56615 char * kwnames[] = {
56616 (char *) "self",(char *) "sibling",(char *) "marg", NULL
56617 };
56618
56619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
56620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56621 if (!SWIG_IsOK(res1)) {
56622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56623 }
56624 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56625 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56626 if (!SWIG_IsOK(res2)) {
56627 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
56628 }
56629 arg2 = reinterpret_cast< wxWindow * >(argp2);
56630 if (obj2) {
56631 ecode3 = SWIG_AsVal_int(obj2, &val3);
56632 if (!SWIG_IsOK(ecode3)) {
56633 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
56634 }
56635 arg3 = static_cast< int >(val3);
56636 }
56637 {
56638 PyThreadState* __tstate = wxPyBeginAllowThreads();
56639 (arg1)->RightOf(arg2,arg3);
56640 wxPyEndAllowThreads(__tstate);
56641 if (PyErr_Occurred()) SWIG_fail;
56642 }
56643 resultobj = SWIG_Py_Void();
56644 return resultobj;
56645 fail:
56646 return NULL;
56647 }
56648
56649
56650 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56651 PyObject *resultobj = 0;
56652 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56653 wxWindow *arg2 = (wxWindow *) 0 ;
56654 int arg3 = (int) 0 ;
56655 void *argp1 = 0 ;
56656 int res1 = 0 ;
56657 void *argp2 = 0 ;
56658 int res2 = 0 ;
56659 int val3 ;
56660 int ecode3 = 0 ;
56661 PyObject * obj0 = 0 ;
56662 PyObject * obj1 = 0 ;
56663 PyObject * obj2 = 0 ;
56664 char * kwnames[] = {
56665 (char *) "self",(char *) "sibling",(char *) "marg", NULL
56666 };
56667
56668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
56669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56670 if (!SWIG_IsOK(res1)) {
56671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56672 }
56673 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56674 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56675 if (!SWIG_IsOK(res2)) {
56676 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
56677 }
56678 arg2 = reinterpret_cast< wxWindow * >(argp2);
56679 if (obj2) {
56680 ecode3 = SWIG_AsVal_int(obj2, &val3);
56681 if (!SWIG_IsOK(ecode3)) {
56682 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
56683 }
56684 arg3 = static_cast< int >(val3);
56685 }
56686 {
56687 PyThreadState* __tstate = wxPyBeginAllowThreads();
56688 (arg1)->Above(arg2,arg3);
56689 wxPyEndAllowThreads(__tstate);
56690 if (PyErr_Occurred()) SWIG_fail;
56691 }
56692 resultobj = SWIG_Py_Void();
56693 return resultobj;
56694 fail:
56695 return NULL;
56696 }
56697
56698
56699 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56700 PyObject *resultobj = 0;
56701 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56702 wxWindow *arg2 = (wxWindow *) 0 ;
56703 int arg3 = (int) 0 ;
56704 void *argp1 = 0 ;
56705 int res1 = 0 ;
56706 void *argp2 = 0 ;
56707 int res2 = 0 ;
56708 int val3 ;
56709 int ecode3 = 0 ;
56710 PyObject * obj0 = 0 ;
56711 PyObject * obj1 = 0 ;
56712 PyObject * obj2 = 0 ;
56713 char * kwnames[] = {
56714 (char *) "self",(char *) "sibling",(char *) "marg", NULL
56715 };
56716
56717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
56718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56719 if (!SWIG_IsOK(res1)) {
56720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56721 }
56722 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56723 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56724 if (!SWIG_IsOK(res2)) {
56725 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
56726 }
56727 arg2 = reinterpret_cast< wxWindow * >(argp2);
56728 if (obj2) {
56729 ecode3 = SWIG_AsVal_int(obj2, &val3);
56730 if (!SWIG_IsOK(ecode3)) {
56731 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
56732 }
56733 arg3 = static_cast< int >(val3);
56734 }
56735 {
56736 PyThreadState* __tstate = wxPyBeginAllowThreads();
56737 (arg1)->Below(arg2,arg3);
56738 wxPyEndAllowThreads(__tstate);
56739 if (PyErr_Occurred()) SWIG_fail;
56740 }
56741 resultobj = SWIG_Py_Void();
56742 return resultobj;
56743 fail:
56744 return NULL;
56745 }
56746
56747
56748 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56749 PyObject *resultobj = 0;
56750 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56751 wxWindow *arg2 = (wxWindow *) 0 ;
56752 wxEdge arg3 ;
56753 int arg4 = (int) 0 ;
56754 void *argp1 = 0 ;
56755 int res1 = 0 ;
56756 void *argp2 = 0 ;
56757 int res2 = 0 ;
56758 int val3 ;
56759 int ecode3 = 0 ;
56760 int val4 ;
56761 int ecode4 = 0 ;
56762 PyObject * obj0 = 0 ;
56763 PyObject * obj1 = 0 ;
56764 PyObject * obj2 = 0 ;
56765 PyObject * obj3 = 0 ;
56766 char * kwnames[] = {
56767 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
56768 };
56769
56770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
56771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56772 if (!SWIG_IsOK(res1)) {
56773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56774 }
56775 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56776 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56777 if (!SWIG_IsOK(res2)) {
56778 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
56779 }
56780 arg2 = reinterpret_cast< wxWindow * >(argp2);
56781 ecode3 = SWIG_AsVal_int(obj2, &val3);
56782 if (!SWIG_IsOK(ecode3)) {
56783 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
56784 }
56785 arg3 = static_cast< wxEdge >(val3);
56786 if (obj3) {
56787 ecode4 = SWIG_AsVal_int(obj3, &val4);
56788 if (!SWIG_IsOK(ecode4)) {
56789 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
56790 }
56791 arg4 = static_cast< int >(val4);
56792 }
56793 {
56794 PyThreadState* __tstate = wxPyBeginAllowThreads();
56795 (arg1)->SameAs(arg2,arg3,arg4);
56796 wxPyEndAllowThreads(__tstate);
56797 if (PyErr_Occurred()) SWIG_fail;
56798 }
56799 resultobj = SWIG_Py_Void();
56800 return resultobj;
56801 fail:
56802 return NULL;
56803 }
56804
56805
56806 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56807 PyObject *resultobj = 0;
56808 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56809 wxWindow *arg2 = (wxWindow *) 0 ;
56810 wxEdge arg3 ;
56811 int arg4 ;
56812 void *argp1 = 0 ;
56813 int res1 = 0 ;
56814 void *argp2 = 0 ;
56815 int res2 = 0 ;
56816 int val3 ;
56817 int ecode3 = 0 ;
56818 int val4 ;
56819 int ecode4 = 0 ;
56820 PyObject * obj0 = 0 ;
56821 PyObject * obj1 = 0 ;
56822 PyObject * obj2 = 0 ;
56823 PyObject * obj3 = 0 ;
56824 char * kwnames[] = {
56825 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
56826 };
56827
56828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
56829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56830 if (!SWIG_IsOK(res1)) {
56831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56832 }
56833 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56834 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56835 if (!SWIG_IsOK(res2)) {
56836 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
56837 }
56838 arg2 = reinterpret_cast< wxWindow * >(argp2);
56839 ecode3 = SWIG_AsVal_int(obj2, &val3);
56840 if (!SWIG_IsOK(ecode3)) {
56841 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
56842 }
56843 arg3 = static_cast< wxEdge >(val3);
56844 ecode4 = SWIG_AsVal_int(obj3, &val4);
56845 if (!SWIG_IsOK(ecode4)) {
56846 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
56847 }
56848 arg4 = static_cast< int >(val4);
56849 {
56850 PyThreadState* __tstate = wxPyBeginAllowThreads();
56851 (arg1)->PercentOf(arg2,arg3,arg4);
56852 wxPyEndAllowThreads(__tstate);
56853 if (PyErr_Occurred()) SWIG_fail;
56854 }
56855 resultobj = SWIG_Py_Void();
56856 return resultobj;
56857 fail:
56858 return NULL;
56859 }
56860
56861
56862 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56863 PyObject *resultobj = 0;
56864 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56865 int arg2 ;
56866 void *argp1 = 0 ;
56867 int res1 = 0 ;
56868 int val2 ;
56869 int ecode2 = 0 ;
56870 PyObject * obj0 = 0 ;
56871 PyObject * obj1 = 0 ;
56872 char * kwnames[] = {
56873 (char *) "self",(char *) "val", NULL
56874 };
56875
56876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
56877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56878 if (!SWIG_IsOK(res1)) {
56879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56880 }
56881 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56882 ecode2 = SWIG_AsVal_int(obj1, &val2);
56883 if (!SWIG_IsOK(ecode2)) {
56884 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
56885 }
56886 arg2 = static_cast< int >(val2);
56887 {
56888 PyThreadState* __tstate = wxPyBeginAllowThreads();
56889 (arg1)->Absolute(arg2);
56890 wxPyEndAllowThreads(__tstate);
56891 if (PyErr_Occurred()) SWIG_fail;
56892 }
56893 resultobj = SWIG_Py_Void();
56894 return resultobj;
56895 fail:
56896 return NULL;
56897 }
56898
56899
56900 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56901 PyObject *resultobj = 0;
56902 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56903 void *argp1 = 0 ;
56904 int res1 = 0 ;
56905 PyObject *swig_obj[1] ;
56906
56907 if (!args) SWIG_fail;
56908 swig_obj[0] = args;
56909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56910 if (!SWIG_IsOK(res1)) {
56911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56912 }
56913 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56914 {
56915 PyThreadState* __tstate = wxPyBeginAllowThreads();
56916 (arg1)->Unconstrained();
56917 wxPyEndAllowThreads(__tstate);
56918 if (PyErr_Occurred()) SWIG_fail;
56919 }
56920 resultobj = SWIG_Py_Void();
56921 return resultobj;
56922 fail:
56923 return NULL;
56924 }
56925
56926
56927 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56928 PyObject *resultobj = 0;
56929 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56930 void *argp1 = 0 ;
56931 int res1 = 0 ;
56932 PyObject *swig_obj[1] ;
56933
56934 if (!args) SWIG_fail;
56935 swig_obj[0] = args;
56936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56937 if (!SWIG_IsOK(res1)) {
56938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56939 }
56940 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56941 {
56942 PyThreadState* __tstate = wxPyBeginAllowThreads();
56943 (arg1)->AsIs();
56944 wxPyEndAllowThreads(__tstate);
56945 if (PyErr_Occurred()) SWIG_fail;
56946 }
56947 resultobj = SWIG_Py_Void();
56948 return resultobj;
56949 fail:
56950 return NULL;
56951 }
56952
56953
56954 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56955 PyObject *resultobj = 0;
56956 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56957 wxWindow *result = 0 ;
56958 void *argp1 = 0 ;
56959 int res1 = 0 ;
56960 PyObject *swig_obj[1] ;
56961
56962 if (!args) SWIG_fail;
56963 swig_obj[0] = args;
56964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56965 if (!SWIG_IsOK(res1)) {
56966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56967 }
56968 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56969 {
56970 PyThreadState* __tstate = wxPyBeginAllowThreads();
56971 result = (wxWindow *)(arg1)->GetOtherWindow();
56972 wxPyEndAllowThreads(__tstate);
56973 if (PyErr_Occurred()) SWIG_fail;
56974 }
56975 {
56976 resultobj = wxPyMake_wxObject(result, 0);
56977 }
56978 return resultobj;
56979 fail:
56980 return NULL;
56981 }
56982
56983
56984 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56985 PyObject *resultobj = 0;
56986 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56987 wxEdge result;
56988 void *argp1 = 0 ;
56989 int res1 = 0 ;
56990 PyObject *swig_obj[1] ;
56991
56992 if (!args) SWIG_fail;
56993 swig_obj[0] = args;
56994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56995 if (!SWIG_IsOK(res1)) {
56996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
56997 }
56998 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56999 {
57000 PyThreadState* __tstate = wxPyBeginAllowThreads();
57001 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
57002 wxPyEndAllowThreads(__tstate);
57003 if (PyErr_Occurred()) SWIG_fail;
57004 }
57005 resultobj = SWIG_From_int(static_cast< int >(result));
57006 return resultobj;
57007 fail:
57008 return NULL;
57009 }
57010
57011
57012 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57013 PyObject *resultobj = 0;
57014 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57015 wxEdge arg2 ;
57016 void *argp1 = 0 ;
57017 int res1 = 0 ;
57018 int val2 ;
57019 int ecode2 = 0 ;
57020 PyObject * obj0 = 0 ;
57021 PyObject * obj1 = 0 ;
57022 char * kwnames[] = {
57023 (char *) "self",(char *) "which", NULL
57024 };
57025
57026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
57027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57028 if (!SWIG_IsOK(res1)) {
57029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57030 }
57031 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57032 ecode2 = SWIG_AsVal_int(obj1, &val2);
57033 if (!SWIG_IsOK(ecode2)) {
57034 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
57035 }
57036 arg2 = static_cast< wxEdge >(val2);
57037 {
57038 PyThreadState* __tstate = wxPyBeginAllowThreads();
57039 (arg1)->SetEdge(arg2);
57040 wxPyEndAllowThreads(__tstate);
57041 if (PyErr_Occurred()) SWIG_fail;
57042 }
57043 resultobj = SWIG_Py_Void();
57044 return resultobj;
57045 fail:
57046 return NULL;
57047 }
57048
57049
57050 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57051 PyObject *resultobj = 0;
57052 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57053 int arg2 ;
57054 void *argp1 = 0 ;
57055 int res1 = 0 ;
57056 int val2 ;
57057 int ecode2 = 0 ;
57058 PyObject * obj0 = 0 ;
57059 PyObject * obj1 = 0 ;
57060 char * kwnames[] = {
57061 (char *) "self",(char *) "v", NULL
57062 };
57063
57064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
57065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57066 if (!SWIG_IsOK(res1)) {
57067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57068 }
57069 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57070 ecode2 = SWIG_AsVal_int(obj1, &val2);
57071 if (!SWIG_IsOK(ecode2)) {
57072 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
57073 }
57074 arg2 = static_cast< int >(val2);
57075 {
57076 PyThreadState* __tstate = wxPyBeginAllowThreads();
57077 (arg1)->SetValue(arg2);
57078 wxPyEndAllowThreads(__tstate);
57079 if (PyErr_Occurred()) SWIG_fail;
57080 }
57081 resultobj = SWIG_Py_Void();
57082 return resultobj;
57083 fail:
57084 return NULL;
57085 }
57086
57087
57088 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57089 PyObject *resultobj = 0;
57090 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57091 int result;
57092 void *argp1 = 0 ;
57093 int res1 = 0 ;
57094 PyObject *swig_obj[1] ;
57095
57096 if (!args) SWIG_fail;
57097 swig_obj[0] = args;
57098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57099 if (!SWIG_IsOK(res1)) {
57100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57101 }
57102 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57103 {
57104 PyThreadState* __tstate = wxPyBeginAllowThreads();
57105 result = (int)(arg1)->GetMargin();
57106 wxPyEndAllowThreads(__tstate);
57107 if (PyErr_Occurred()) SWIG_fail;
57108 }
57109 resultobj = SWIG_From_int(static_cast< int >(result));
57110 return resultobj;
57111 fail:
57112 return NULL;
57113 }
57114
57115
57116 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57117 PyObject *resultobj = 0;
57118 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57119 int arg2 ;
57120 void *argp1 = 0 ;
57121 int res1 = 0 ;
57122 int val2 ;
57123 int ecode2 = 0 ;
57124 PyObject * obj0 = 0 ;
57125 PyObject * obj1 = 0 ;
57126 char * kwnames[] = {
57127 (char *) "self",(char *) "m", NULL
57128 };
57129
57130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
57131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57132 if (!SWIG_IsOK(res1)) {
57133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57134 }
57135 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57136 ecode2 = SWIG_AsVal_int(obj1, &val2);
57137 if (!SWIG_IsOK(ecode2)) {
57138 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
57139 }
57140 arg2 = static_cast< int >(val2);
57141 {
57142 PyThreadState* __tstate = wxPyBeginAllowThreads();
57143 (arg1)->SetMargin(arg2);
57144 wxPyEndAllowThreads(__tstate);
57145 if (PyErr_Occurred()) SWIG_fail;
57146 }
57147 resultobj = SWIG_Py_Void();
57148 return resultobj;
57149 fail:
57150 return NULL;
57151 }
57152
57153
57154 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57155 PyObject *resultobj = 0;
57156 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57157 int result;
57158 void *argp1 = 0 ;
57159 int res1 = 0 ;
57160 PyObject *swig_obj[1] ;
57161
57162 if (!args) SWIG_fail;
57163 swig_obj[0] = args;
57164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57165 if (!SWIG_IsOK(res1)) {
57166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
57167 }
57168 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57169 {
57170 PyThreadState* __tstate = wxPyBeginAllowThreads();
57171 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
57172 wxPyEndAllowThreads(__tstate);
57173 if (PyErr_Occurred()) SWIG_fail;
57174 }
57175 resultobj = SWIG_From_int(static_cast< int >(result));
57176 return resultobj;
57177 fail:
57178 return NULL;
57179 }
57180
57181
57182 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57183 PyObject *resultobj = 0;
57184 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57185 int result;
57186 void *argp1 = 0 ;
57187 int res1 = 0 ;
57188 PyObject *swig_obj[1] ;
57189
57190 if (!args) SWIG_fail;
57191 swig_obj[0] = args;
57192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57193 if (!SWIG_IsOK(res1)) {
57194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
57195 }
57196 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57197 {
57198 PyThreadState* __tstate = wxPyBeginAllowThreads();
57199 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
57200 wxPyEndAllowThreads(__tstate);
57201 if (PyErr_Occurred()) SWIG_fail;
57202 }
57203 resultobj = SWIG_From_int(static_cast< int >(result));
57204 return resultobj;
57205 fail:
57206 return NULL;
57207 }
57208
57209
57210 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57211 PyObject *resultobj = 0;
57212 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57213 int result;
57214 void *argp1 = 0 ;
57215 int res1 = 0 ;
57216 PyObject *swig_obj[1] ;
57217
57218 if (!args) SWIG_fail;
57219 swig_obj[0] = args;
57220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57221 if (!SWIG_IsOK(res1)) {
57222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
57223 }
57224 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57225 {
57226 PyThreadState* __tstate = wxPyBeginAllowThreads();
57227 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
57228 wxPyEndAllowThreads(__tstate);
57229 if (PyErr_Occurred()) SWIG_fail;
57230 }
57231 resultobj = SWIG_From_int(static_cast< int >(result));
57232 return resultobj;
57233 fail:
57234 return NULL;
57235 }
57236
57237
57238 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57239 PyObject *resultobj = 0;
57240 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57241 bool result;
57242 void *argp1 = 0 ;
57243 int res1 = 0 ;
57244 PyObject *swig_obj[1] ;
57245
57246 if (!args) SWIG_fail;
57247 swig_obj[0] = args;
57248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57249 if (!SWIG_IsOK(res1)) {
57250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
57251 }
57252 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57253 {
57254 PyThreadState* __tstate = wxPyBeginAllowThreads();
57255 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
57256 wxPyEndAllowThreads(__tstate);
57257 if (PyErr_Occurred()) SWIG_fail;
57258 }
57259 {
57260 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
57261 }
57262 return resultobj;
57263 fail:
57264 return NULL;
57265 }
57266
57267
57268 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57269 PyObject *resultobj = 0;
57270 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57271 bool arg2 ;
57272 void *argp1 = 0 ;
57273 int res1 = 0 ;
57274 bool val2 ;
57275 int ecode2 = 0 ;
57276 PyObject * obj0 = 0 ;
57277 PyObject * obj1 = 0 ;
57278 char * kwnames[] = {
57279 (char *) "self",(char *) "d", NULL
57280 };
57281
57282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
57283 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57284 if (!SWIG_IsOK(res1)) {
57285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57286 }
57287 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57288 ecode2 = SWIG_AsVal_bool(obj1, &val2);
57289 if (!SWIG_IsOK(ecode2)) {
57290 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
57291 }
57292 arg2 = static_cast< bool >(val2);
57293 {
57294 PyThreadState* __tstate = wxPyBeginAllowThreads();
57295 (arg1)->SetDone(arg2);
57296 wxPyEndAllowThreads(__tstate);
57297 if (PyErr_Occurred()) SWIG_fail;
57298 }
57299 resultobj = SWIG_Py_Void();
57300 return resultobj;
57301 fail:
57302 return NULL;
57303 }
57304
57305
57306 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57307 PyObject *resultobj = 0;
57308 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57309 wxRelationship result;
57310 void *argp1 = 0 ;
57311 int res1 = 0 ;
57312 PyObject *swig_obj[1] ;
57313
57314 if (!args) SWIG_fail;
57315 swig_obj[0] = args;
57316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57317 if (!SWIG_IsOK(res1)) {
57318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57319 }
57320 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57321 {
57322 PyThreadState* __tstate = wxPyBeginAllowThreads();
57323 result = (wxRelationship)(arg1)->GetRelationship();
57324 wxPyEndAllowThreads(__tstate);
57325 if (PyErr_Occurred()) SWIG_fail;
57326 }
57327 resultobj = SWIG_From_int(static_cast< int >(result));
57328 return resultobj;
57329 fail:
57330 return NULL;
57331 }
57332
57333
57334 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57335 PyObject *resultobj = 0;
57336 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57337 wxRelationship arg2 ;
57338 void *argp1 = 0 ;
57339 int res1 = 0 ;
57340 int val2 ;
57341 int ecode2 = 0 ;
57342 PyObject * obj0 = 0 ;
57343 PyObject * obj1 = 0 ;
57344 char * kwnames[] = {
57345 (char *) "self",(char *) "r", NULL
57346 };
57347
57348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
57349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57350 if (!SWIG_IsOK(res1)) {
57351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57352 }
57353 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57354 ecode2 = SWIG_AsVal_int(obj1, &val2);
57355 if (!SWIG_IsOK(ecode2)) {
57356 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
57357 }
57358 arg2 = static_cast< wxRelationship >(val2);
57359 {
57360 PyThreadState* __tstate = wxPyBeginAllowThreads();
57361 (arg1)->SetRelationship(arg2);
57362 wxPyEndAllowThreads(__tstate);
57363 if (PyErr_Occurred()) SWIG_fail;
57364 }
57365 resultobj = SWIG_Py_Void();
57366 return resultobj;
57367 fail:
57368 return NULL;
57369 }
57370
57371
57372 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57373 PyObject *resultobj = 0;
57374 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57375 wxWindow *arg2 = (wxWindow *) 0 ;
57376 bool result;
57377 void *argp1 = 0 ;
57378 int res1 = 0 ;
57379 void *argp2 = 0 ;
57380 int res2 = 0 ;
57381 PyObject * obj0 = 0 ;
57382 PyObject * obj1 = 0 ;
57383 char * kwnames[] = {
57384 (char *) "self",(char *) "otherW", NULL
57385 };
57386
57387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
57388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57389 if (!SWIG_IsOK(res1)) {
57390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57391 }
57392 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57393 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
57394 if (!SWIG_IsOK(res2)) {
57395 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
57396 }
57397 arg2 = reinterpret_cast< wxWindow * >(argp2);
57398 {
57399 PyThreadState* __tstate = wxPyBeginAllowThreads();
57400 result = (bool)(arg1)->ResetIfWin(arg2);
57401 wxPyEndAllowThreads(__tstate);
57402 if (PyErr_Occurred()) SWIG_fail;
57403 }
57404 {
57405 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
57406 }
57407 return resultobj;
57408 fail:
57409 return NULL;
57410 }
57411
57412
57413 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57414 PyObject *resultobj = 0;
57415 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57416 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
57417 wxWindow *arg3 = (wxWindow *) 0 ;
57418 bool result;
57419 void *argp1 = 0 ;
57420 int res1 = 0 ;
57421 void *argp2 = 0 ;
57422 int res2 = 0 ;
57423 void *argp3 = 0 ;
57424 int res3 = 0 ;
57425 PyObject * obj0 = 0 ;
57426 PyObject * obj1 = 0 ;
57427 PyObject * obj2 = 0 ;
57428 char * kwnames[] = {
57429 (char *) "self",(char *) "constraints",(char *) "win", NULL
57430 };
57431
57432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
57433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57434 if (!SWIG_IsOK(res1)) {
57435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57436 }
57437 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57438 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57439 if (!SWIG_IsOK(res2)) {
57440 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
57441 }
57442 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
57443 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
57444 if (!SWIG_IsOK(res3)) {
57445 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
57446 }
57447 arg3 = reinterpret_cast< wxWindow * >(argp3);
57448 {
57449 PyThreadState* __tstate = wxPyBeginAllowThreads();
57450 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
57451 wxPyEndAllowThreads(__tstate);
57452 if (PyErr_Occurred()) SWIG_fail;
57453 }
57454 {
57455 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
57456 }
57457 return resultobj;
57458 fail:
57459 return NULL;
57460 }
57461
57462
57463 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57464 PyObject *resultobj = 0;
57465 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57466 wxEdge arg2 ;
57467 wxWindow *arg3 = (wxWindow *) 0 ;
57468 wxWindow *arg4 = (wxWindow *) 0 ;
57469 int result;
57470 void *argp1 = 0 ;
57471 int res1 = 0 ;
57472 int val2 ;
57473 int ecode2 = 0 ;
57474 void *argp3 = 0 ;
57475 int res3 = 0 ;
57476 void *argp4 = 0 ;
57477 int res4 = 0 ;
57478 PyObject * obj0 = 0 ;
57479 PyObject * obj1 = 0 ;
57480 PyObject * obj2 = 0 ;
57481 PyObject * obj3 = 0 ;
57482 char * kwnames[] = {
57483 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
57484 };
57485
57486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
57487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57488 if (!SWIG_IsOK(res1)) {
57489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
57490 }
57491 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57492 ecode2 = SWIG_AsVal_int(obj1, &val2);
57493 if (!SWIG_IsOK(ecode2)) {
57494 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
57495 }
57496 arg2 = static_cast< wxEdge >(val2);
57497 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
57498 if (!SWIG_IsOK(res3)) {
57499 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
57500 }
57501 arg3 = reinterpret_cast< wxWindow * >(argp3);
57502 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
57503 if (!SWIG_IsOK(res4)) {
57504 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
57505 }
57506 arg4 = reinterpret_cast< wxWindow * >(argp4);
57507 {
57508 PyThreadState* __tstate = wxPyBeginAllowThreads();
57509 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
57510 wxPyEndAllowThreads(__tstate);
57511 if (PyErr_Occurred()) SWIG_fail;
57512 }
57513 resultobj = SWIG_From_int(static_cast< int >(result));
57514 return resultobj;
57515 fail:
57516 return NULL;
57517 }
57518
57519
57520 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57521 PyObject *obj;
57522 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
57523 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
57524 return SWIG_Py_Void();
57525 }
57526
57527 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57528 PyObject *resultobj = 0;
57529 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57530 wxIndividualLayoutConstraint *result = 0 ;
57531 void *argp1 = 0 ;
57532 int res1 = 0 ;
57533 PyObject *swig_obj[1] ;
57534
57535 if (!args) SWIG_fail;
57536 swig_obj[0] = args;
57537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57538 if (!SWIG_IsOK(res1)) {
57539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
57540 }
57541 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57542 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
57543 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57544 return resultobj;
57545 fail:
57546 return NULL;
57547 }
57548
57549
57550 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57551 PyObject *resultobj = 0;
57552 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57553 wxIndividualLayoutConstraint *result = 0 ;
57554 void *argp1 = 0 ;
57555 int res1 = 0 ;
57556 PyObject *swig_obj[1] ;
57557
57558 if (!args) SWIG_fail;
57559 swig_obj[0] = args;
57560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57561 if (!SWIG_IsOK(res1)) {
57562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
57563 }
57564 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57565 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
57566 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57567 return resultobj;
57568 fail:
57569 return NULL;
57570 }
57571
57572
57573 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57574 PyObject *resultobj = 0;
57575 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57576 wxIndividualLayoutConstraint *result = 0 ;
57577 void *argp1 = 0 ;
57578 int res1 = 0 ;
57579 PyObject *swig_obj[1] ;
57580
57581 if (!args) SWIG_fail;
57582 swig_obj[0] = args;
57583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57584 if (!SWIG_IsOK(res1)) {
57585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
57586 }
57587 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57588 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
57589 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57590 return resultobj;
57591 fail:
57592 return NULL;
57593 }
57594
57595
57596 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57597 PyObject *resultobj = 0;
57598 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57599 wxIndividualLayoutConstraint *result = 0 ;
57600 void *argp1 = 0 ;
57601 int res1 = 0 ;
57602 PyObject *swig_obj[1] ;
57603
57604 if (!args) SWIG_fail;
57605 swig_obj[0] = args;
57606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57607 if (!SWIG_IsOK(res1)) {
57608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
57609 }
57610 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57611 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
57612 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57613 return resultobj;
57614 fail:
57615 return NULL;
57616 }
57617
57618
57619 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57620 PyObject *resultobj = 0;
57621 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57622 wxIndividualLayoutConstraint *result = 0 ;
57623 void *argp1 = 0 ;
57624 int res1 = 0 ;
57625 PyObject *swig_obj[1] ;
57626
57627 if (!args) SWIG_fail;
57628 swig_obj[0] = args;
57629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57630 if (!SWIG_IsOK(res1)) {
57631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
57632 }
57633 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57634 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
57635 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57636 return resultobj;
57637 fail:
57638 return NULL;
57639 }
57640
57641
57642 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57643 PyObject *resultobj = 0;
57644 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57645 wxIndividualLayoutConstraint *result = 0 ;
57646 void *argp1 = 0 ;
57647 int res1 = 0 ;
57648 PyObject *swig_obj[1] ;
57649
57650 if (!args) SWIG_fail;
57651 swig_obj[0] = args;
57652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57653 if (!SWIG_IsOK(res1)) {
57654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
57655 }
57656 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57657 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
57658 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57659 return resultobj;
57660 fail:
57661 return NULL;
57662 }
57663
57664
57665 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57666 PyObject *resultobj = 0;
57667 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57668 wxIndividualLayoutConstraint *result = 0 ;
57669 void *argp1 = 0 ;
57670 int res1 = 0 ;
57671 PyObject *swig_obj[1] ;
57672
57673 if (!args) SWIG_fail;
57674 swig_obj[0] = args;
57675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57676 if (!SWIG_IsOK(res1)) {
57677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
57678 }
57679 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57680 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
57681 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57682 return resultobj;
57683 fail:
57684 return NULL;
57685 }
57686
57687
57688 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57689 PyObject *resultobj = 0;
57690 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57691 wxIndividualLayoutConstraint *result = 0 ;
57692 void *argp1 = 0 ;
57693 int res1 = 0 ;
57694 PyObject *swig_obj[1] ;
57695
57696 if (!args) SWIG_fail;
57697 swig_obj[0] = args;
57698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57699 if (!SWIG_IsOK(res1)) {
57700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
57701 }
57702 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57703 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
57704 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57705 return resultobj;
57706 fail:
57707 return NULL;
57708 }
57709
57710
57711 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57712 PyObject *resultobj = 0;
57713 wxLayoutConstraints *result = 0 ;
57714
57715 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
57716 {
57717 PyThreadState* __tstate = wxPyBeginAllowThreads();
57718 result = (wxLayoutConstraints *)new wxLayoutConstraints();
57719 wxPyEndAllowThreads(__tstate);
57720 if (PyErr_Occurred()) SWIG_fail;
57721 }
57722 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
57723 return resultobj;
57724 fail:
57725 return NULL;
57726 }
57727
57728
57729 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57730 PyObject *resultobj = 0;
57731 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57732 void *argp1 = 0 ;
57733 int res1 = 0 ;
57734 PyObject *swig_obj[1] ;
57735
57736 if (!args) SWIG_fail;
57737 swig_obj[0] = args;
57738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
57739 if (!SWIG_IsOK(res1)) {
57740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
57741 }
57742 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57743 {
57744 PyThreadState* __tstate = wxPyBeginAllowThreads();
57745 delete arg1;
57746
57747 wxPyEndAllowThreads(__tstate);
57748 if (PyErr_Occurred()) SWIG_fail;
57749 }
57750 resultobj = SWIG_Py_Void();
57751 return resultobj;
57752 fail:
57753 return NULL;
57754 }
57755
57756
57757 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57758 PyObject *resultobj = 0;
57759 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57760 wxWindow *arg2 = (wxWindow *) 0 ;
57761 int *arg3 = (int *) 0 ;
57762 bool result;
57763 void *argp1 = 0 ;
57764 int res1 = 0 ;
57765 void *argp2 = 0 ;
57766 int res2 = 0 ;
57767 int temp3 ;
57768 int res3 = SWIG_TMPOBJ ;
57769 PyObject * obj0 = 0 ;
57770 PyObject * obj1 = 0 ;
57771 char * kwnames[] = {
57772 (char *) "self",(char *) "win", NULL
57773 };
57774
57775 arg3 = &temp3;
57776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
57777 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57778 if (!SWIG_IsOK(res1)) {
57779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
57780 }
57781 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57782 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
57783 if (!SWIG_IsOK(res2)) {
57784 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
57785 }
57786 arg2 = reinterpret_cast< wxWindow * >(argp2);
57787 {
57788 PyThreadState* __tstate = wxPyBeginAllowThreads();
57789 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
57790 wxPyEndAllowThreads(__tstate);
57791 if (PyErr_Occurred()) SWIG_fail;
57792 }
57793 {
57794 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
57795 }
57796 if (SWIG_IsTmpObj(res3)) {
57797 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
57798 } else {
57799 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
57800 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
57801 }
57802 return resultobj;
57803 fail:
57804 return NULL;
57805 }
57806
57807
57808 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57809 PyObject *resultobj = 0;
57810 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57811 bool result;
57812 void *argp1 = 0 ;
57813 int res1 = 0 ;
57814 PyObject *swig_obj[1] ;
57815
57816 if (!args) SWIG_fail;
57817 swig_obj[0] = args;
57818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57819 if (!SWIG_IsOK(res1)) {
57820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
57821 }
57822 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57823 {
57824 PyThreadState* __tstate = wxPyBeginAllowThreads();
57825 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
57826 wxPyEndAllowThreads(__tstate);
57827 if (PyErr_Occurred()) SWIG_fail;
57828 }
57829 {
57830 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
57831 }
57832 return resultobj;
57833 fail:
57834 return NULL;
57835 }
57836
57837
57838 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57839 PyObject *obj;
57840 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
57841 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
57842 return SWIG_Py_Void();
57843 }
57844
57845 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57846 return SWIG_Python_InitShadowInstance(args);
57847 }
57848
57849 static PyMethodDef SwigMethods[] = {
57850 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
57851 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
57852 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
57853 { (char *)"Object_IsSameAs", (PyCFunction) _wrap_Object_IsSameAs, METH_VARARGS | METH_KEYWORDS, NULL},
57854 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
57855 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
57856 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
57857 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
57858 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
57859 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
57860 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
57861 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57862 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57863 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
57864 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
57865 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
57866 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
57867 { (char *)"Size_IncBy", (PyCFunction) _wrap_Size_IncBy, METH_VARARGS | METH_KEYWORDS, NULL},
57868 { (char *)"Size_DecBy", (PyCFunction) _wrap_Size_DecBy, METH_VARARGS | METH_KEYWORDS, NULL},
57869 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
57870 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57871 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
57872 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
57873 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
57874 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
57875 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
57876 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
57877 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
57878 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
57879 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
57880 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
57881 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
57882 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
57883 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
57884 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57885 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
57886 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57887 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57888 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
57889 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
57890 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57891 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
57892 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
57893 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
57894 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
57895 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
57896 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
57897 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
57898 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
57899 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
57900 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57901 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57902 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
57903 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
57904 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
57905 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
57906 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57907 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
57908 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
57909 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
57910 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
57911 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
57912 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
57913 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
57914 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
57915 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
57916 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
57917 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
57918 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
57919 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
57920 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
57921 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
57922 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
57923 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
57924 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57925 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
57926 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
57927 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
57928 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
57929 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
57930 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
57931 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
57932 { (char *)"Rect_GetTopRight", (PyCFunction)_wrap_Rect_GetTopRight, METH_O, NULL},
57933 { (char *)"Rect_SetTopRight", (PyCFunction) _wrap_Rect_SetTopRight, METH_VARARGS | METH_KEYWORDS, NULL},
57934 { (char *)"Rect_GetBottomLeft", (PyCFunction)_wrap_Rect_GetBottomLeft, METH_O, NULL},
57935 { (char *)"Rect_SetBottomLeft", (PyCFunction) _wrap_Rect_SetBottomLeft, METH_VARARGS | METH_KEYWORDS, NULL},
57936 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
57937 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
57938 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
57939 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
57940 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
57941 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
57942 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
57943 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
57944 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
57945 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
57946 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
57947 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
57948 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
57949 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
57950 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
57951 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
57952 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57953 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57954 { (char *)"Rect_ContainsXY", (PyCFunction) _wrap_Rect_ContainsXY, METH_VARARGS | METH_KEYWORDS, NULL},
57955 { (char *)"Rect_Contains", (PyCFunction) _wrap_Rect_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
57956 { (char *)"Rect_ContainsRect", (PyCFunction) _wrap_Rect_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
57957 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
57958 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
57959 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
57960 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
57961 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
57962 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
57963 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
57964 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
57965 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
57966 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
57967 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57968 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
57969 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
57970 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
57971 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
57972 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
57973 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
57974 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57975 { (char *)"delete_Point2D", (PyCFunction)_wrap_delete_Point2D, METH_O, NULL},
57976 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
57977 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
57978 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
57979 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
57980 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
57981 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
57982 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
57983 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
57984 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
57985 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
57986 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
57987 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
57988 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
57989 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
57990 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
57991 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57992 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57993 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
57994 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
57995 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
57996 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
57997 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57998 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
57999 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
58000 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
58001 { (char *)"new_Rect2D", (PyCFunction) _wrap_new_Rect2D, METH_VARARGS | METH_KEYWORDS, NULL},
58002 { (char *)"delete_Rect2D", (PyCFunction)_wrap_delete_Rect2D, METH_O, NULL},
58003 { (char *)"Rect2D_GetPosition", (PyCFunction)_wrap_Rect2D_GetPosition, METH_O, NULL},
58004 { (char *)"Rect2D_GetSize", (PyCFunction)_wrap_Rect2D_GetSize, METH_O, NULL},
58005 { (char *)"Rect2D_GetLeft", (PyCFunction)_wrap_Rect2D_GetLeft, METH_O, NULL},
58006 { (char *)"Rect2D_SetLeft", (PyCFunction) _wrap_Rect2D_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
58007 { (char *)"Rect2D_MoveLeftTo", (PyCFunction) _wrap_Rect2D_MoveLeftTo, METH_VARARGS | METH_KEYWORDS, NULL},
58008 { (char *)"Rect2D_GetTop", (PyCFunction)_wrap_Rect2D_GetTop, METH_O, NULL},
58009 { (char *)"Rect2D_SetTop", (PyCFunction) _wrap_Rect2D_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
58010 { (char *)"Rect2D_MoveTopTo", (PyCFunction) _wrap_Rect2D_MoveTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
58011 { (char *)"Rect2D_GetBottom", (PyCFunction)_wrap_Rect2D_GetBottom, METH_O, NULL},
58012 { (char *)"Rect2D_SetBottom", (PyCFunction) _wrap_Rect2D_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
58013 { (char *)"Rect2D_MoveBottomTo", (PyCFunction) _wrap_Rect2D_MoveBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
58014 { (char *)"Rect2D_GetRight", (PyCFunction)_wrap_Rect2D_GetRight, METH_O, NULL},
58015 { (char *)"Rect2D_SetRight", (PyCFunction) _wrap_Rect2D_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
58016 { (char *)"Rect2D_MoveRightTo", (PyCFunction) _wrap_Rect2D_MoveRightTo, METH_VARARGS | METH_KEYWORDS, NULL},
58017 { (char *)"Rect2D_GetLeftTop", (PyCFunction)_wrap_Rect2D_GetLeftTop, METH_O, NULL},
58018 { (char *)"Rect2D_SetLeftTop", (PyCFunction) _wrap_Rect2D_SetLeftTop, METH_VARARGS | METH_KEYWORDS, NULL},
58019 { (char *)"Rect2D_MoveLeftTopTo", (PyCFunction) _wrap_Rect2D_MoveLeftTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
58020 { (char *)"Rect2D_GetLeftBottom", (PyCFunction)_wrap_Rect2D_GetLeftBottom, METH_O, NULL},
58021 { (char *)"Rect2D_SetLeftBottom", (PyCFunction) _wrap_Rect2D_SetLeftBottom, METH_VARARGS | METH_KEYWORDS, NULL},
58022 { (char *)"Rect2D_MoveLeftBottomTo", (PyCFunction) _wrap_Rect2D_MoveLeftBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
58023 { (char *)"Rect2D_GetRightTop", (PyCFunction)_wrap_Rect2D_GetRightTop, METH_O, NULL},
58024 { (char *)"Rect2D_SetRightTop", (PyCFunction) _wrap_Rect2D_SetRightTop, METH_VARARGS | METH_KEYWORDS, NULL},
58025 { (char *)"Rect2D_MoveRightTopTo", (PyCFunction) _wrap_Rect2D_MoveRightTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
58026 { (char *)"Rect2D_GetRightBottom", (PyCFunction)_wrap_Rect2D_GetRightBottom, METH_O, NULL},
58027 { (char *)"Rect2D_SetRightBottom", (PyCFunction) _wrap_Rect2D_SetRightBottom, METH_VARARGS | METH_KEYWORDS, NULL},
58028 { (char *)"Rect2D_MoveRightBottomTo", (PyCFunction) _wrap_Rect2D_MoveRightBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
58029 { (char *)"Rect2D_GetCentre", (PyCFunction)_wrap_Rect2D_GetCentre, METH_O, NULL},
58030 { (char *)"Rect2D_SetCentre", (PyCFunction) _wrap_Rect2D_SetCentre, METH_VARARGS | METH_KEYWORDS, NULL},
58031 { (char *)"Rect2D_MoveCentreTo", (PyCFunction) _wrap_Rect2D_MoveCentreTo, METH_VARARGS | METH_KEYWORDS, NULL},
58032 { (char *)"Rect2D_GetOutcode", (PyCFunction) _wrap_Rect2D_GetOutcode, METH_VARARGS | METH_KEYWORDS, NULL},
58033 { (char *)"Rect2D_Contains", (PyCFunction) _wrap_Rect2D_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
58034 { (char *)"Rect2D_ContainsRect", (PyCFunction) _wrap_Rect2D_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
58035 { (char *)"Rect2D_IsEmpty", (PyCFunction)_wrap_Rect2D_IsEmpty, METH_O, NULL},
58036 { (char *)"Rect2D_HaveEqualSize", (PyCFunction) _wrap_Rect2D_HaveEqualSize, METH_VARARGS | METH_KEYWORDS, NULL},
58037 { (char *)"Rect2D_Inset", _wrap_Rect2D_Inset, METH_VARARGS, NULL},
58038 { (char *)"Rect2D_Offset", (PyCFunction) _wrap_Rect2D_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
58039 { (char *)"Rect2D_ConstrainTo", (PyCFunction) _wrap_Rect2D_ConstrainTo, METH_VARARGS | METH_KEYWORDS, NULL},
58040 { (char *)"Rect2D_Interpolate", (PyCFunction) _wrap_Rect2D_Interpolate, METH_VARARGS | METH_KEYWORDS, NULL},
58041 { (char *)"Rect2D_Intersect", (PyCFunction) _wrap_Rect2D_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
58042 { (char *)"Rect2D_CreateIntersection", (PyCFunction) _wrap_Rect2D_CreateIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
58043 { (char *)"Rect2D_Intersects", (PyCFunction) _wrap_Rect2D_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
58044 { (char *)"Rect2D_Union", (PyCFunction) _wrap_Rect2D_Union, METH_VARARGS | METH_KEYWORDS, NULL},
58045 { (char *)"Rect2D_CreateUnion", (PyCFunction) _wrap_Rect2D_CreateUnion, METH_VARARGS | METH_KEYWORDS, NULL},
58046 { (char *)"Rect2D_Scale", _wrap_Rect2D_Scale, METH_VARARGS, NULL},
58047 { (char *)"Rect2D___eq__", (PyCFunction) _wrap_Rect2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
58048 { (char *)"Rect2D___ne__", (PyCFunction) _wrap_Rect2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
58049 { (char *)"Rect2D_x_set", _wrap_Rect2D_x_set, METH_VARARGS, NULL},
58050 { (char *)"Rect2D_x_get", (PyCFunction)_wrap_Rect2D_x_get, METH_O, NULL},
58051 { (char *)"Rect2D_y_set", _wrap_Rect2D_y_set, METH_VARARGS, NULL},
58052 { (char *)"Rect2D_y_get", (PyCFunction)_wrap_Rect2D_y_get, METH_O, NULL},
58053 { (char *)"Rect2D_width_set", _wrap_Rect2D_width_set, METH_VARARGS, NULL},
58054 { (char *)"Rect2D_width_get", (PyCFunction)_wrap_Rect2D_width_get, METH_O, NULL},
58055 { (char *)"Rect2D_height_set", _wrap_Rect2D_height_set, METH_VARARGS, NULL},
58056 { (char *)"Rect2D_height_get", (PyCFunction)_wrap_Rect2D_height_get, METH_O, NULL},
58057 { (char *)"Rect2D_Set", (PyCFunction) _wrap_Rect2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
58058 { (char *)"Rect2D_Get", (PyCFunction)_wrap_Rect2D_Get, METH_O, NULL},
58059 { (char *)"Rect2D_swigregister", Rect2D_swigregister, METH_VARARGS, NULL},
58060 { (char *)"Rect2D_swiginit", Rect2D_swiginit, METH_VARARGS, NULL},
58061 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
58062 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
58063 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
58064 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
58065 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
58066 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
58067 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
58068 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
58069 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
58070 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
58071 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
58072 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
58073 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
58074 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
58075 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
58076 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
58077 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
58078 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
58079 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
58080 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
58081 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
58082 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
58083 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
58084 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
58085 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
58086 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
58087 { (char *)"FSFile_DetachStream", (PyCFunction)_wrap_FSFile_DetachStream, METH_O, NULL},
58088 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
58089 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
58090 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
58091 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
58092 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
58093 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
58094 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
58095 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
58096 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
58097 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
58098 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
58099 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
58100 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
58101 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
58102 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
58103 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
58104 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
58105 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
58106 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
58107 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
58108 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
58109 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
58110 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
58111 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
58112 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
58113 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
58114 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
58115 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
58116 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58117 { (char *)"FileSystem_RemoveHandler", (PyCFunction) _wrap_FileSystem_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58118 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
58119 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
58120 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
58121 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
58122 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
58123 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
58124 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
58125 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
58126 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
58127 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
58128 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
58129 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
58130 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
58131 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
58132 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
58133 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
58134 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
58135 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
58136 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
58137 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
58138 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
58139 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
58140 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
58141 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
58142 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
58143 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
58144 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
58145 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
58146 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
58147 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
58148 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
58149 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
58150 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
58151 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
58152 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
58153 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
58154 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
58155 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
58156 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
58157 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
58158 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
58159 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
58160 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
58161 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
58162 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
58163 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
58164 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
58165 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
58166 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
58167 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
58168 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
58169 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
58170 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
58171 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
58172 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
58173 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
58174 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
58175 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
58176 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
58177 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
58178 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
58179 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
58180 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
58181 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
58182 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
58183 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
58184 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
58185 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
58186 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
58187 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
58188 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
58189 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
58190 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
58191 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
58192 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
58193 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
58194 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
58195 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
58196 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
58197 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
58198 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
58199 { (char *)"Image_ResampleBox", (PyCFunction) _wrap_Image_ResampleBox, METH_VARARGS | METH_KEYWORDS, NULL},
58200 { (char *)"Image_ResampleBicubic", (PyCFunction) _wrap_Image_ResampleBicubic, METH_VARARGS | METH_KEYWORDS, NULL},
58201 { (char *)"Image_Blur", (PyCFunction) _wrap_Image_Blur, METH_VARARGS | METH_KEYWORDS, NULL},
58202 { (char *)"Image_BlurHorizontal", (PyCFunction) _wrap_Image_BlurHorizontal, METH_VARARGS | METH_KEYWORDS, NULL},
58203 { (char *)"Image_BlurVertical", (PyCFunction) _wrap_Image_BlurVertical, METH_VARARGS | METH_KEYWORDS, NULL},
58204 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
58205 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
58206 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
58207 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
58208 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
58209 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
58210 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
58211 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
58212 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
58213 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
58214 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
58215 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
58216 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
58217 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
58218 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
58219 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
58220 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
58221 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
58222 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
58223 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
58224 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
58225 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
58226 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
58227 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
58228 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
58229 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
58230 { (char *)"Image_IsOk", (PyCFunction)_wrap_Image_IsOk, METH_O, NULL},
58231 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
58232 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
58233 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
58234 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
58235 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
58236 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
58237 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
58238 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
58239 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
58240 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
58241 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
58242 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
58243 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
58244 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
58245 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
58246 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
58247 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
58248 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
58249 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
58250 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
58251 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
58252 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
58253 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
58254 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
58255 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
58256 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
58257 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
58258 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
58259 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
58260 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
58261 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
58262 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
58263 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
58264 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
58265 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
58266 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58267 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58268 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58269 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
58270 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
58271 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
58272 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
58273 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
58274 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
58275 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
58276 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
58277 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
58278 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
58279 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
58280 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
58281 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
58282 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
58283 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
58284 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
58285 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
58286 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
58287 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
58288 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
58289 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
58290 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
58291 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
58292 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
58293 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
58294 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
58295 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
58296 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
58297 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
58298 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
58299 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
58300 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
58301 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
58302 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
58303 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
58304 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
58305 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
58306 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
58307 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
58308 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
58309 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
58310 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
58311 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
58312 { (char *)"new_TGAHandler", (PyCFunction)_wrap_new_TGAHandler, METH_NOARGS, NULL},
58313 { (char *)"TGAHandler_swigregister", TGAHandler_swigregister, METH_VARARGS, NULL},
58314 { (char *)"TGAHandler_swiginit", TGAHandler_swiginit, METH_VARARGS, NULL},
58315 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
58316 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
58317 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
58318 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
58319 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
58320 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58321 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58322 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
58323 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
58324 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58325 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58326 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
58327 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
58328 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
58329 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
58330 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
58331 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
58332 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
58333 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
58334 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
58335 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
58336 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
58337 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
58338 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
58339 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
58340 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
58341 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
58342 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
58343 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
58344 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
58345 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
58346 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
58347 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
58348 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
58349 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
58350 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
58351 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
58352 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
58353 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
58354 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
58355 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
58356 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
58357 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
58358 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58359 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
58360 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
58361 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
58362 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
58363 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
58364 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
58365 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
58366 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
58367 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
58368 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
58369 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
58370 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
58371 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
58372 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
58373 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58374 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
58375 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
58376 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
58377 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
58378 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
58379 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58380 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
58381 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
58382 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
58383 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
58384 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
58385 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
58386 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58387 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
58388 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
58389 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
58390 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
58391 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
58392 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
58393 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58394 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
58395 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
58396 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
58397 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
58398 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
58399 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
58400 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
58401 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
58402 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
58403 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
58404 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
58405 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
58406 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
58407 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
58408 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
58409 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
58410 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
58411 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
58412 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
58413 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
58414 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
58415 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
58416 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
58417 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
58418 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
58419 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
58420 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
58421 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
58422 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
58423 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
58424 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
58425 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
58426 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
58427 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
58428 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
58429 { (char *)"MouseEvent_GetWheelAxis", (PyCFunction)_wrap_MouseEvent_GetWheelAxis, METH_O, NULL},
58430 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
58431 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
58432 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
58433 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
58434 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
58435 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
58436 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
58437 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
58438 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
58439 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
58440 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
58441 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
58442 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
58443 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
58444 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
58445 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
58446 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
58447 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
58448 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
58449 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
58450 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
58451 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
58452 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
58453 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
58454 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
58455 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
58456 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
58457 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
58458 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58459 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
58460 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
58461 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
58462 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
58463 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
58464 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
58465 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
58466 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58467 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
58468 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
58469 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
58470 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
58471 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
58472 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
58473 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
58474 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
58475 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
58476 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
58477 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
58478 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
58479 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
58480 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
58481 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
58482 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
58483 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
58484 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
58485 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
58486 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
58487 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
58488 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
58489 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
58490 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
58491 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
58492 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
58493 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
58494 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
58495 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
58496 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
58497 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
58498 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
58499 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
58500 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
58501 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
58502 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
58503 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
58504 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
58505 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58506 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
58507 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
58508 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
58509 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
58510 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
58511 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
58512 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
58513 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
58514 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
58515 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
58516 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58517 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
58518 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
58519 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
58520 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
58521 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
58522 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
58523 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58524 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
58525 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
58526 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58527 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
58528 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
58529 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58530 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
58531 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
58532 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
58533 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58534 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
58535 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
58536 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
58537 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
58538 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58539 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
58540 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
58541 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
58542 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58543 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
58544 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
58545 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
58546 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58547 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
58548 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
58549 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58550 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
58551 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
58552 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
58553 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
58554 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
58555 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58556 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
58557 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
58558 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
58559 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
58560 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
58561 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
58562 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
58563 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
58564 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58565 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
58566 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
58567 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
58568 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
58569 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58570 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
58571 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
58572 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
58573 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58574 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
58575 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
58576 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
58577 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
58578 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
58579 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
58580 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58581 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
58582 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
58583 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
58584 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
58585 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
58586 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
58587 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
58588 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
58589 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
58590 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
58591 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
58592 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
58593 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
58594 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
58595 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
58596 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
58597 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
58598 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
58599 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
58600 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
58601 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
58602 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
58603 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
58604 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58605 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
58606 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
58607 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
58608 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58609 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
58610 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
58611 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
58612 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
58613 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
58614 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58615 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
58616 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
58617 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
58618 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
58619 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58620 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
58621 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
58622 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
58623 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
58624 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
58625 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
58626 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
58627 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
58628 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
58629 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
58630 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
58631 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
58632 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
58633 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
58634 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
58635 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
58636 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58637 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
58638 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
58639 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
58640 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58641 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
58642 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
58643 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
58644 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58645 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
58646 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
58647 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
58648 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
58649 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
58650 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
58651 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
58652 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
58653 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
58654 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
58655 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
58656 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
58657 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58658 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
58659 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
58660 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58661 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
58662 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
58663 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
58664 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
58665 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
58666 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58667 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
58668 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
58669 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
58670 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
58671 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
58672 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58673 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
58674 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
58675 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
58676 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
58677 { (char *)"new_EventBlocker", (PyCFunction) _wrap_new_EventBlocker, METH_VARARGS | METH_KEYWORDS, NULL},
58678 { (char *)"delete_EventBlocker", (PyCFunction)_wrap_delete_EventBlocker, METH_O, NULL},
58679 { (char *)"EventBlocker_Block", (PyCFunction) _wrap_EventBlocker_Block, METH_VARARGS | METH_KEYWORDS, NULL},
58680 { (char *)"EventBlocker_swigregister", EventBlocker_swigregister, METH_VARARGS, NULL},
58681 { (char *)"EventBlocker_swiginit", EventBlocker_swiginit, METH_VARARGS, NULL},
58682 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
58683 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
58684 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
58685 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
58686 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
58687 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
58688 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
58689 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
58690 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
58691 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
58692 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
58693 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
58694 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
58695 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
58696 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
58697 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
58698 { (char *)"PyApp_GetLayoutDirection", (PyCFunction)_wrap_PyApp_GetLayoutDirection, METH_O, NULL},
58699 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
58700 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
58701 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
58702 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
58703 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
58704 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
58705 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
58706 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
58707 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
58708 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
58709 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
58710 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
58711 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
58712 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
58713 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
58714 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
58715 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
58716 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
58717 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
58718 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
58719 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
58720 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
58721 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
58722 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
58723 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
58724 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
58725 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
58726 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
58727 { (char *)"PyApp_IsDisplayAvailable", (PyCFunction)_wrap_PyApp_IsDisplayAvailable, METH_NOARGS, NULL},
58728 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
58729 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
58730 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
58731 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
58732 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
58733 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
58734 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
58735 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58736 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
58737 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
58738 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
58739 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
58740 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
58741 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
58742 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
58743 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
58744 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
58745 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
58746 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
58747 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
58748 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
58749 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
58750 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
58751 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
58752 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
58753 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
58754 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
58755 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
58756 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
58757 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
58758 { (char *)"AcceleratorEntry_Create", (PyCFunction) _wrap_AcceleratorEntry_Create, METH_VARARGS | METH_KEYWORDS, NULL},
58759 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
58760 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
58761 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
58762 { (char *)"AcceleratorEntry_IsOk", (PyCFunction)_wrap_AcceleratorEntry_IsOk, METH_O, NULL},
58763 { (char *)"AcceleratorEntry_ToString", (PyCFunction)_wrap_AcceleratorEntry_ToString, METH_O, NULL},
58764 { (char *)"AcceleratorEntry_FromString", (PyCFunction) _wrap_AcceleratorEntry_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
58765 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
58766 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
58767 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
58768 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
58769 { (char *)"AcceleratorTable_IsOk", (PyCFunction)_wrap_AcceleratorTable_IsOk, METH_O, NULL},
58770 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
58771 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
58772 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
58773 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
58774 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
58775 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
58776 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
58777 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
58778 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
58779 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
58780 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
58781 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
58782 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
58783 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
58784 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
58785 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
58786 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
58787 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
58788 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
58789 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
58790 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
58791 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
58792 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
58793 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
58794 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
58795 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
58796 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
58797 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
58798 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
58799 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
58800 { (char *)"Window_GetLayoutDirection", (PyCFunction)_wrap_Window_GetLayoutDirection, METH_O, NULL},
58801 { (char *)"Window_SetLayoutDirection", (PyCFunction) _wrap_Window_SetLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
58802 { (char *)"Window_AdjustForLayoutDirection", (PyCFunction) _wrap_Window_AdjustForLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
58803 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
58804 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
58805 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
58806 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
58807 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
58808 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
58809 { (char *)"Window_SetInitialSize", (PyCFunction) _wrap_Window_SetInitialSize, METH_VARARGS | METH_KEYWORDS, NULL},
58810 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
58811 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
58812 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
58813 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
58814 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
58815 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
58816 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
58817 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
58818 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
58819 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
58820 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
58821 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
58822 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
58823 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
58824 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
58825 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
58826 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
58827 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
58828 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
58829 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
58830 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
58831 { (char *)"Window_GetEffectiveMinSize", (PyCFunction)_wrap_Window_GetEffectiveMinSize, METH_O, NULL},
58832 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
58833 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
58834 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
58835 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
58836 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
58837 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
58838 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
58839 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
58840 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
58841 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
58842 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
58843 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
58844 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
58845 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
58846 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
58847 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
58848 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
58849 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
58850 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
58851 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
58852 { (char *)"Window_GetWindowBorderSize", (PyCFunction)_wrap_Window_GetWindowBorderSize, METH_O, NULL},
58853 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
58854 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
58855 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
58856 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
58857 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
58858 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
58859 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
58860 { (char *)"Window_IsThisEnabled", (PyCFunction)_wrap_Window_IsThisEnabled, METH_O, NULL},
58861 { (char *)"Window_IsShownOnScreen", (PyCFunction)_wrap_Window_IsShownOnScreen, METH_O, NULL},
58862 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
58863 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
58864 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
58865 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
58866 { (char *)"Window_ToggleWindowStyle", (PyCFunction) _wrap_Window_ToggleWindowStyle, METH_VARARGS | METH_KEYWORDS, NULL},
58867 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
58868 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
58869 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
58870 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
58871 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
58872 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
58873 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
58874 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
58875 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
58876 { (char *)"Window_CanAcceptFocus", (PyCFunction)_wrap_Window_CanAcceptFocus, METH_O, NULL},
58877 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
58878 { (char *)"Window_CanAcceptFocusFromKeyboard", (PyCFunction)_wrap_Window_CanAcceptFocusFromKeyboard, METH_O, NULL},
58879 { (char *)"Window_NavigateIn", (PyCFunction) _wrap_Window_NavigateIn, METH_VARARGS | METH_KEYWORDS, NULL},
58880 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
58881 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
58882 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
58883 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
58884 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
58885 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
58886 { (char *)"Window_GetTopLevelParent", (PyCFunction)_wrap_Window_GetTopLevelParent, METH_O, NULL},
58887 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
58888 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
58889 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
58890 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
58891 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
58892 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
58893 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
58894 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
58895 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58896 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58897 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58898 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58899 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
58900 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
58901 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
58902 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
58903 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
58904 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
58905 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
58906 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
58907 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
58908 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
58909 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
58910 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
58911 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
58912 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
58913 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
58914 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
58915 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
58916 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
58917 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
58918 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
58919 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
58920 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
58921 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
58922 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
58923 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
58924 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
58925 { (char *)"Window_IsFrozen", (PyCFunction)_wrap_Window_IsFrozen, METH_O, NULL},
58926 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
58927 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
58928 { (char *)"Window_IsDoubleBuffered", (PyCFunction)_wrap_Window_IsDoubleBuffered, METH_O, NULL},
58929 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
58930 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
58931 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
58932 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
58933 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
58934 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
58935 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
58936 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
58937 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
58938 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
58939 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
58940 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
58941 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
58942 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
58943 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
58944 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
58945 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
58946 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
58947 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
58948 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
58949 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
58950 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
58951 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
58952 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
58953 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
58954 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
58955 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
58956 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
58957 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
58958 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
58959 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
58960 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
58961 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
58962 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
58963 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
58964 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
58965 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
58966 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
58967 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
58968 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
58969 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
58970 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
58971 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
58972 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
58973 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
58974 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
58975 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
58976 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
58977 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
58978 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
58979 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
58980 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
58981 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
58982 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
58983 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
58984 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
58985 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
58986 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
58987 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
58988 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
58989 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
58990 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
58991 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
58992 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
58993 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
58994 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
58995 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
58996 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
58997 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
58998 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
58999 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
59000 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59001 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
59002 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
59003 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59004 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
59005 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
59006 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
59007 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
59008 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
59009 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
59010 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
59011 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
59012 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
59013 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
59014 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
59015 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
59016 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
59017 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
59018 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
59019 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
59020 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
59021 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
59022 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59023 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
59024 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
59025 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
59026 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
59027 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
59028 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
59029 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
59030 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
59031 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
59032 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
59033 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
59034 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
59035 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
59036 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59037 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59038 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
59039 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
59040 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
59041 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
59042 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
59043 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
59044 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
59045 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
59046 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59047 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
59048 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
59049 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
59050 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
59051 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59052 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
59053 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
59054 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
59055 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
59056 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
59057 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
59058 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
59059 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
59060 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
59061 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
59062 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
59063 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
59064 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
59065 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
59066 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
59067 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
59068 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
59069 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
59070 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
59071 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
59072 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
59073 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
59074 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
59075 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
59076 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59077 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
59078 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
59079 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
59080 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
59081 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
59082 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
59083 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
59084 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
59085 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
59086 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
59087 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
59088 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
59089 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
59090 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
59091 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
59092 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59093 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
59094 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
59095 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
59096 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
59097 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
59098 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
59099 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
59100 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
59101 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59102 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
59103 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
59104 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
59105 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
59106 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
59107 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
59108 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
59109 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
59110 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
59111 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
59112 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
59113 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
59114 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
59115 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59116 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
59117 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
59118 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
59119 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
59120 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
59121 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
59122 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59123 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
59124 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
59125 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
59126 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
59127 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
59128 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
59129 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
59130 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
59131 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
59132 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
59133 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
59134 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
59135 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59136 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
59137 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
59138 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
59139 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
59140 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
59141 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
59142 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
59143 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
59144 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
59145 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
59146 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
59147 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
59148 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
59149 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
59150 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
59151 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
59152 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
59153 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
59154 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
59155 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
59156 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
59157 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
59158 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
59159 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
59160 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
59161 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
59162 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
59163 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
59164 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
59165 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
59166 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
59167 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
59168 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
59169 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
59170 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
59171 { (char *)"Control_RemoveMnemonics", (PyCFunction) _wrap_Control_RemoveMnemonics, METH_VARARGS | METH_KEYWORDS, NULL},
59172 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
59173 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
59174 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
59175 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
59176 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
59177 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
59178 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
59179 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
59180 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
59181 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
59182 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
59183 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
59184 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
59185 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
59186 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
59187 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
59188 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
59189 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
59190 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
59191 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
59192 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
59193 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
59194 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
59195 { (char *)"new_SizerFlags", (PyCFunction) _wrap_new_SizerFlags, METH_VARARGS | METH_KEYWORDS, NULL},
59196 { (char *)"delete_SizerFlags", (PyCFunction)_wrap_delete_SizerFlags, METH_O, NULL},
59197 { (char *)"SizerFlags_Proportion", (PyCFunction) _wrap_SizerFlags_Proportion, METH_VARARGS | METH_KEYWORDS, NULL},
59198 { (char *)"SizerFlags_Align", (PyCFunction) _wrap_SizerFlags_Align, METH_VARARGS | METH_KEYWORDS, NULL},
59199 { (char *)"SizerFlags_Expand", (PyCFunction)_wrap_SizerFlags_Expand, METH_O, NULL},
59200 { (char *)"SizerFlags_Centre", (PyCFunction)_wrap_SizerFlags_Centre, METH_O, NULL},
59201 { (char *)"SizerFlags_Center", (PyCFunction)_wrap_SizerFlags_Center, METH_O, NULL},
59202 { (char *)"SizerFlags_Left", (PyCFunction)_wrap_SizerFlags_Left, METH_O, NULL},
59203 { (char *)"SizerFlags_Right", (PyCFunction)_wrap_SizerFlags_Right, METH_O, NULL},
59204 { (char *)"SizerFlags_Top", (PyCFunction)_wrap_SizerFlags_Top, METH_O, NULL},
59205 { (char *)"SizerFlags_Bottom", (PyCFunction)_wrap_SizerFlags_Bottom, METH_O, NULL},
59206 { (char *)"SizerFlags_Shaped", (PyCFunction)_wrap_SizerFlags_Shaped, METH_O, NULL},
59207 { (char *)"SizerFlags_FixedMinSize", (PyCFunction)_wrap_SizerFlags_FixedMinSize, METH_O, NULL},
59208 { (char *)"SizerFlags_Border", (PyCFunction) _wrap_SizerFlags_Border, METH_VARARGS | METH_KEYWORDS, NULL},
59209 { (char *)"SizerFlags_DoubleBorder", (PyCFunction) _wrap_SizerFlags_DoubleBorder, METH_VARARGS | METH_KEYWORDS, NULL},
59210 { (char *)"SizerFlags_TripleBorder", (PyCFunction) _wrap_SizerFlags_TripleBorder, METH_VARARGS | METH_KEYWORDS, NULL},
59211 { (char *)"SizerFlags_HorzBorder", (PyCFunction)_wrap_SizerFlags_HorzBorder, METH_O, NULL},
59212 { (char *)"SizerFlags_DoubleHorzBorder", (PyCFunction)_wrap_SizerFlags_DoubleHorzBorder, METH_O, NULL},
59213 { (char *)"SizerFlags_GetDefaultBorder", (PyCFunction)_wrap_SizerFlags_GetDefaultBorder, METH_NOARGS, NULL},
59214 { (char *)"SizerFlags_GetProportion", (PyCFunction)_wrap_SizerFlags_GetProportion, METH_O, NULL},
59215 { (char *)"SizerFlags_GetFlags", (PyCFunction)_wrap_SizerFlags_GetFlags, METH_O, NULL},
59216 { (char *)"SizerFlags_GetBorderInPixels", (PyCFunction)_wrap_SizerFlags_GetBorderInPixels, METH_O, NULL},
59217 { (char *)"SizerFlags_swigregister", SizerFlags_swigregister, METH_VARARGS, NULL},
59218 { (char *)"SizerFlags_swiginit", SizerFlags_swiginit, METH_VARARGS, NULL},
59219 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
59220 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
59221 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59222 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
59223 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59224 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
59225 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
59226 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
59227 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
59228 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
59229 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
59230 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
59231 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
59232 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
59233 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
59234 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
59235 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
59236 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
59237 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
59238 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
59239 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
59240 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
59241 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
59242 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
59243 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
59244 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
59245 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
59246 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
59247 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
59248 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
59249 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59250 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59251 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
59252 { (char *)"SizerItem_AssignWindow", (PyCFunction) _wrap_SizerItem_AssignWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59253 { (char *)"SizerItem_AssignSizer", (PyCFunction) _wrap_SizerItem_AssignSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59254 { (char *)"SizerItem_AssignSpacer", (PyCFunction) _wrap_SizerItem_AssignSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
59255 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
59256 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
59257 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
59258 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
59259 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
59260 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
59261 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
59262 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
59263 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
59264 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
59265 { (char *)"Sizer_AddF", (PyCFunction) _wrap_Sizer_AddF, METH_VARARGS | METH_KEYWORDS, NULL},
59266 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
59267 { (char *)"Sizer_InsertF", (PyCFunction) _wrap_Sizer_InsertF, METH_VARARGS | METH_KEYWORDS, NULL},
59268 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
59269 { (char *)"Sizer_PrependF", (PyCFunction) _wrap_Sizer_PrependF, METH_VARARGS | METH_KEYWORDS, NULL},
59270 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
59271 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
59272 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
59273 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
59274 { (char *)"Sizer__ReplaceWin", (PyCFunction) _wrap_Sizer__ReplaceWin, METH_VARARGS | METH_KEYWORDS, NULL},
59275 { (char *)"Sizer__ReplaceSizer", (PyCFunction) _wrap_Sizer__ReplaceSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59276 { (char *)"Sizer__ReplaceItem", (PyCFunction) _wrap_Sizer__ReplaceItem, METH_VARARGS | METH_KEYWORDS, NULL},
59277 { (char *)"Sizer_SetContainingWindow", (PyCFunction) _wrap_Sizer_SetContainingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59278 { (char *)"Sizer_GetContainingWindow", (PyCFunction)_wrap_Sizer_GetContainingWindow, METH_O, NULL},
59279 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
59280 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
59281 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
59282 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
59283 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
59284 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
59285 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
59286 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
59287 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
59288 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
59289 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
59290 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
59291 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
59292 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
59293 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
59294 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
59295 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
59296 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
59297 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
59298 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
59299 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
59300 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
59301 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
59302 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
59303 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
59304 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
59305 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59306 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
59307 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
59308 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
59309 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
59310 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59311 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
59312 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
59313 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
59314 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59315 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
59316 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
59317 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
59318 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
59319 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
59320 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
59321 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
59322 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
59323 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
59324 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
59325 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59326 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
59327 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
59328 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
59329 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
59330 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
59331 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
59332 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
59333 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
59334 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
59335 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
59336 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
59337 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
59338 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
59339 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
59340 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
59341 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
59342 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
59343 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
59344 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
59345 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
59346 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
59347 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
59348 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
59349 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
59350 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
59351 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
59352 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
59353 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
59354 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
59355 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
59356 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
59357 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
59358 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
59359 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
59360 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
59361 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
59362 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
59363 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
59364 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
59365 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
59366 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
59367 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
59368 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
59369 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
59370 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
59371 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
59372 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
59373 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
59374 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
59375 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
59376 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
59377 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59378 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59379 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
59380 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
59381 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
59382 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
59383 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
59384 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
59385 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
59386 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
59387 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
59388 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59389 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
59390 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
59391 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59392 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
59393 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
59394 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
59395 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
59396 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
59397 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
59398 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
59399 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
59400 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
59401 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
59402 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
59403 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
59404 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
59405 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
59406 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
59407 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
59408 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
59409 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
59410 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
59411 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
59412 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
59413 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
59414 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
59415 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
59416 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
59417 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
59418 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
59419 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
59420 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
59421 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
59422 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
59423 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
59424 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
59425 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
59426 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
59427 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
59428 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
59429 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
59430 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
59431 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
59432 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
59433 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
59434 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
59435 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
59436 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
59437 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
59438 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
59439 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
59440 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
59441 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
59442 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
59443 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
59444 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
59445 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
59446 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
59447 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
59448 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
59449 { NULL, NULL, 0, NULL }
59450 };
59451
59452
59453 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
59454
59455 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
59456 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
59457 }
59458 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
59459 return (void *)((wxEvent *) ((wxMenuEvent *) x));
59460 }
59461 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
59462 return (void *)((wxEvent *) ((wxCloseEvent *) x));
59463 }
59464 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
59465 return (void *)((wxEvent *) ((wxMouseEvent *) x));
59466 }
59467 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
59468 return (void *)((wxEvent *) ((wxEraseEvent *) x));
59469 }
59470 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
59471 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
59472 }
59473 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
59474 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
59475 }
59476 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
59477 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
59478 }
59479 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
59480 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
59481 }
59482 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
59483 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
59484 }
59485 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
59486 return (void *)((wxEvent *) ((wxPyEvent *) x));
59487 }
59488 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
59489 return (void *)((wxEvent *) ((wxIdleEvent *) x));
59490 }
59491 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
59492 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
59493 }
59494 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
59495 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
59496 }
59497 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
59498 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
59499 }
59500 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
59501 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
59502 }
59503 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
59504 return (void *)((wxEvent *) ((wxActivateEvent *) x));
59505 }
59506 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
59507 return (void *)((wxEvent *) ((wxSizeEvent *) x));
59508 }
59509 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
59510 return (void *)((wxEvent *) ((wxMoveEvent *) x));
59511 }
59512 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
59513 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
59514 }
59515 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
59516 return (void *)((wxEvent *) ((wxPaintEvent *) x));
59517 }
59518 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
59519 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
59520 }
59521 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
59522 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
59523 }
59524 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
59525 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
59526 }
59527 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
59528 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
59529 }
59530 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
59531 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
59532 }
59533 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
59534 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
59535 }
59536 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
59537 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
59538 }
59539 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
59540 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
59541 }
59542 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
59543 return (void *)((wxEvent *) ((wxFocusEvent *) x));
59544 }
59545 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
59546 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
59547 }
59548 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
59549 return (void *)((wxEvent *) ((wxShowEvent *) x));
59550 }
59551 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
59552 return (void *)((wxEvent *) ((wxCommandEvent *) x));
59553 }
59554 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
59555 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
59556 }
59557 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
59558 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
59559 }
59560 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
59561 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
59562 }
59563 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
59564 return (void *)((wxEvent *) ((wxKeyEvent *) x));
59565 }
59566 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
59567 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
59568 }
59569 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
59570 return (void *)((wxValidator *) ((wxPyValidator *) x));
59571 }
59572 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
59573 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
59574 }
59575 static void *_p_wxEventBlockerTo_p_wxObject(void *x) {
59576 return (void *)((wxObject *) (wxEvtHandler *) ((wxEventBlocker *) x));
59577 }
59578 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
59579 return (void *)((wxObject *) ((wxSizerItem *) x));
59580 }
59581 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
59582 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
59583 }
59584 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
59585 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
59586 }
59587 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
59588 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
59589 }
59590 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
59591 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
59592 }
59593 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
59594 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
59595 }
59596 static void *_p_wxSizerTo_p_wxObject(void *x) {
59597 return (void *)((wxObject *) ((wxSizer *) x));
59598 }
59599 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
59600 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
59601 }
59602 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
59603 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
59604 }
59605 static void *_p_wxEventTo_p_wxObject(void *x) {
59606 return (void *)((wxObject *) ((wxEvent *) x));
59607 }
59608 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
59609 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
59610 }
59611 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
59612 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
59613 }
59614 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
59615 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
59616 }
59617 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
59618 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
59619 }
59620 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
59621 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
59622 }
59623 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
59624 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
59625 }
59626 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
59627 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
59628 }
59629 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
59630 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
59631 }
59632 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
59633 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
59634 }
59635 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
59636 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
59637 }
59638 static void *_p_wxControlTo_p_wxObject(void *x) {
59639 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
59640 }
59641 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
59642 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
59643 }
59644 static void *_p_wxFSFileTo_p_wxObject(void *x) {
59645 return (void *)((wxObject *) ((wxFSFile *) x));
59646 }
59647 static void *_p_wxPySizerTo_p_wxObject(void *x) {
59648 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
59649 }
59650 static void *_p_wxPyEventTo_p_wxObject(void *x) {
59651 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
59652 }
59653 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
59654 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
59655 }
59656 static void *_p_wxShowEventTo_p_wxObject(void *x) {
59657 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
59658 }
59659 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
59660 return (void *)((wxObject *) ((wxMenuItem *) x));
59661 }
59662 static void *_p_wxDateEventTo_p_wxObject(void *x) {
59663 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
59664 }
59665 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
59666 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
59667 }
59668 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
59669 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
59670 }
59671 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
59672 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
59673 }
59674 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
59675 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
59676 }
59677 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
59678 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
59679 }
59680 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
59681 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
59682 }
59683 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
59684 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
59685 }
59686 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
59687 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
59688 }
59689 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
59690 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
59691 }
59692 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
59693 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
59694 }
59695 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
59696 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
59697 }
59698 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
59699 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
59700 }
59701 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
59702 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
59703 }
59704 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
59705 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
59706 }
59707 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
59708 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
59709 }
59710 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
59711 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
59712 }
59713 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
59714 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
59715 }
59716 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
59717 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
59718 }
59719 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
59720 return (void *)((wxObject *) ((wxImageHandler *) x));
59721 }
59722 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
59723 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
59724 }
59725 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
59726 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
59727 }
59728 static void *_p_wxTGAHandlerTo_p_wxObject(void *x) {
59729 return (void *)((wxObject *) (wxImageHandler *) ((wxTGAHandler *) x));
59730 }
59731 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
59732 return (void *)((wxObject *) ((wxEvtHandler *) x));
59733 }
59734 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
59735 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
59736 }
59737 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
59738 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
59739 }
59740 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
59741 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
59742 }
59743 static void *_p_wxImageTo_p_wxObject(void *x) {
59744 return (void *)((wxObject *) ((wxImage *) x));
59745 }
59746 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
59747 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
59748 }
59749 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
59750 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
59751 }
59752 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
59753 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
59754 }
59755 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
59756 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
59757 }
59758 static void *_p_wxWindowTo_p_wxObject(void *x) {
59759 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
59760 }
59761 static void *_p_wxMenuTo_p_wxObject(void *x) {
59762 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
59763 }
59764 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
59765 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
59766 }
59767 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
59768 return (void *)((wxObject *) ((wxFileSystem *) x));
59769 }
59770 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
59771 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
59772 }
59773 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
59774 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
59775 }
59776 static void *_p_wxPyAppTo_p_wxObject(void *x) {
59777 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
59778 }
59779 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
59780 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
59781 }
59782 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
59783 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
59784 }
59785 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
59786 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
59787 }
59788 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
59789 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
59790 }
59791 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
59792 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
59793 }
59794 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
59795 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
59796 }
59797 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
59798 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
59799 }
59800 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
59801 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
59802 }
59803 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
59804 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
59805 }
59806 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
59807 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
59808 }
59809 static void *_p_wxValidatorTo_p_wxObject(void *x) {
59810 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
59811 }
59812 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
59813 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
59814 }
59815 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
59816 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
59817 }
59818 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
59819 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
59820 }
59821 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
59822 return (void *)((wxControl *) ((wxControlWithItems *) x));
59823 }
59824 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
59825 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
59826 }
59827 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
59828 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
59829 }
59830 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
59831 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
59832 }
59833 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
59834 return (void *)((wxSizer *) ((wxBoxSizer *) x));
59835 }
59836 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
59837 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
59838 }
59839 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
59840 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
59841 }
59842 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
59843 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
59844 }
59845 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
59846 return (void *)((wxSizer *) ((wxGridSizer *) x));
59847 }
59848 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
59849 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
59850 }
59851 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
59852 return (void *)((wxSizer *) ((wxPySizer *) x));
59853 }
59854 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
59855 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
59856 }
59857 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
59858 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
59859 }
59860 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
59861 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
59862 }
59863 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
59864 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
59865 }
59866 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
59867 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
59868 }
59869 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
59870 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
59871 }
59872 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
59873 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
59874 }
59875 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
59876 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
59877 }
59878 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
59879 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
59880 }
59881 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
59882 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
59883 }
59884 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
59885 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
59886 }
59887 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
59888 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
59889 }
59890 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
59891 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
59892 }
59893 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
59894 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
59895 }
59896 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
59897 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
59898 }
59899 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
59900 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
59901 }
59902 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
59903 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
59904 }
59905 static void *_p_wxTGAHandlerTo_p_wxImageHandler(void *x) {
59906 return (void *)((wxImageHandler *) ((wxTGAHandler *) x));
59907 }
59908 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
59909 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
59910 }
59911 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
59912 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
59913 }
59914 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
59915 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
59916 }
59917 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
59918 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
59919 }
59920 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
59921 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
59922 }
59923 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
59924 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
59925 }
59926 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
59927 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
59928 }
59929 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
59930 return (void *)((wxEvtHandler *) ((wxWindow *) x));
59931 }
59932 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
59933 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
59934 }
59935 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
59936 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
59937 }
59938 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
59939 return (void *)((wxEvtHandler *) ((wxValidator *) x));
59940 }
59941 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
59942 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
59943 }
59944 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
59945 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
59946 }
59947 static void *_p_wxEventBlockerTo_p_wxEvtHandler(void *x) {
59948 return (void *)((wxEvtHandler *) ((wxEventBlocker *) x));
59949 }
59950 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
59951 return (void *)((wxEvtHandler *) ((wxMenu *) x));
59952 }
59953 static void *_p_wxControlTo_p_wxWindow(void *x) {
59954 return (void *)((wxWindow *) ((wxControl *) x));
59955 }
59956 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
59957 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
59958 }
59959 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
59960 return (void *)((wxWindow *) ((wxMenuBar *) x));
59961 }
59962 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
59963 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
59964 }
59965 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
59966 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
59967 }
59968 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
59969 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
59970 }
59971 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
59972 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
59973 }
59974 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
59975 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
59976 }
59977 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
59978 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
59979 }
59980 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
59981 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
59982 }
59983 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
59984 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
59985 }
59986 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
59987 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
59988 }
59989 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
59990 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
59991 }
59992 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
59993 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
59994 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};
59995 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
59996 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
59997 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
59998 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
59999 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
60000 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
60001 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
60002 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
60003 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
60004 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
60005 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
60006 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
60007 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
60008 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
60009 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
60010 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
60011 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
60012 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
60013 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
60014 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
60015 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
60016 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
60017 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
60018 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
60019 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
60020 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
60021 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
60022 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
60023 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
60024 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
60025 static swig_type_info _swigt__p_wxDouble = {"_p_wxDouble", "wxDouble *", 0, 0, (void*)0, 0};
60026 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
60027 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
60028 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
60029 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
60030 static swig_type_info _swigt__p_wxEventBlocker = {"_p_wxEventBlocker", "wxEventBlocker *", 0, 0, (void*)0, 0};
60031 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
60032 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
60033 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
60034 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
60035 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
60036 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
60037 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
60038 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
60039 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
60040 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
60041 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
60042 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
60043 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
60044 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
60045 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
60046 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
60047 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
60048 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
60049 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
60050 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
60051 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
60052 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
60053 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
60054 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
60055 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
60056 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
60057 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
60058 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
60059 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
60060 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
60061 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
60062 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
60063 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
60064 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
60065 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
60066 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
60067 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
60068 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
60069 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
60070 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
60071 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
60072 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
60073 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
60074 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
60075 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
60076 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
60077 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
60078 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
60079 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
60080 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
60081 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
60082 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
60083 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
60084 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
60085 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
60086 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
60087 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
60088 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
60089 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
60090 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
60091 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
60092 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
60093 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
60094 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
60095 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
60096 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
60097 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
60098 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
60099 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
60100 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
60101 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
60102 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
60103 static swig_type_info _swigt__p_wxRect2D = {"_p_wxRect2D", "wxRect2D *", 0, 0, (void*)0, 0};
60104 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
60105 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
60106 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
60107 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
60108 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
60109 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
60110 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
60111 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
60112 static swig_type_info _swigt__p_wxSizerFlags = {"_p_wxSizerFlags", "wxSizerFlags *", 0, 0, (void*)0, 0};
60113 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
60114 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
60115 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
60116 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
60117 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
60118 static swig_type_info _swigt__p_wxTGAHandler = {"_p_wxTGAHandler", "wxTGAHandler *", 0, 0, (void*)0, 0};
60119 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
60120 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
60121 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
60122 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
60123 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
60124 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
60125 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
60126 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
60127 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
60128 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
60129
60130 static swig_type_info *swig_type_initial[] = {
60131 &_swigt__p_buffer,
60132 &_swigt__p_char,
60133 &_swigt__p_form_ops_t,
60134 &_swigt__p_int,
60135 &_swigt__p_long,
60136 &_swigt__p_unsigned_char,
60137 &_swigt__p_unsigned_int,
60138 &_swigt__p_unsigned_long,
60139 &_swigt__p_wxANIHandler,
60140 &_swigt__p_wxAcceleratorEntry,
60141 &_swigt__p_wxAcceleratorTable,
60142 &_swigt__p_wxActivateEvent,
60143 &_swigt__p_wxAppTraits,
60144 &_swigt__p_wxArrayString,
60145 &_swigt__p_wxBMPHandler,
60146 &_swigt__p_wxBitmap,
60147 &_swigt__p_wxBoxSizer,
60148 &_swigt__p_wxButton,
60149 &_swigt__p_wxCURHandler,
60150 &_swigt__p_wxCaret,
60151 &_swigt__p_wxChildFocusEvent,
60152 &_swigt__p_wxClipboardTextEvent,
60153 &_swigt__p_wxCloseEvent,
60154 &_swigt__p_wxColour,
60155 &_swigt__p_wxCommandEvent,
60156 &_swigt__p_wxContextMenuEvent,
60157 &_swigt__p_wxControl,
60158 &_swigt__p_wxControlWithItems,
60159 &_swigt__p_wxCursor,
60160 &_swigt__p_wxDC,
60161 &_swigt__p_wxDateEvent,
60162 &_swigt__p_wxDateTime,
60163 &_swigt__p_wxDisplayChangedEvent,
60164 &_swigt__p_wxDouble,
60165 &_swigt__p_wxDropFilesEvent,
60166 &_swigt__p_wxDuplexMode,
60167 &_swigt__p_wxEraseEvent,
60168 &_swigt__p_wxEvent,
60169 &_swigt__p_wxEventBlocker,
60170 &_swigt__p_wxEventLoop,
60171 &_swigt__p_wxEventLoopActivator,
60172 &_swigt__p_wxEvtHandler,
60173 &_swigt__p_wxFSFile,
60174 &_swigt__p_wxFileSystem,
60175 &_swigt__p_wxFileSystemHandler,
60176 &_swigt__p_wxFlexGridSizer,
60177 &_swigt__p_wxFocusEvent,
60178 &_swigt__p_wxFont,
60179 &_swigt__p_wxFrame,
60180 &_swigt__p_wxGBPosition,
60181 &_swigt__p_wxGBSizerItem,
60182 &_swigt__p_wxGBSpan,
60183 &_swigt__p_wxGIFHandler,
60184 &_swigt__p_wxGridBagSizer,
60185 &_swigt__p_wxGridSizer,
60186 &_swigt__p_wxHelpEvent__Origin,
60187 &_swigt__p_wxICOHandler,
60188 &_swigt__p_wxIconizeEvent,
60189 &_swigt__p_wxIdleEvent,
60190 &_swigt__p_wxImage,
60191 &_swigt__p_wxImageHandler,
60192 &_swigt__p_wxImageHistogram,
60193 &_swigt__p_wxImage_HSVValue,
60194 &_swigt__p_wxImage_RGBValue,
60195 &_swigt__p_wxIndividualLayoutConstraint,
60196 &_swigt__p_wxInitDialogEvent,
60197 &_swigt__p_wxInputStream,
60198 &_swigt__p_wxInternetFSHandler,
60199 &_swigt__p_wxItemContainer,
60200 &_swigt__p_wxJPEGHandler,
60201 &_swigt__p_wxKeyEvent,
60202 &_swigt__p_wxLayoutConstraints,
60203 &_swigt__p_wxMaximizeEvent,
60204 &_swigt__p_wxMemoryFSHandler,
60205 &_swigt__p_wxMenu,
60206 &_swigt__p_wxMenuBar,
60207 &_swigt__p_wxMenuBarBase,
60208 &_swigt__p_wxMenuEvent,
60209 &_swigt__p_wxMenuItem,
60210 &_swigt__p_wxMouseCaptureChangedEvent,
60211 &_swigt__p_wxMouseCaptureLostEvent,
60212 &_swigt__p_wxMouseEvent,
60213 &_swigt__p_wxMoveEvent,
60214 &_swigt__p_wxNavigationKeyEvent,
60215 &_swigt__p_wxNcPaintEvent,
60216 &_swigt__p_wxNotifyEvent,
60217 &_swigt__p_wxObject,
60218 &_swigt__p_wxOutputStream,
60219 &_swigt__p_wxPCXHandler,
60220 &_swigt__p_wxPNGHandler,
60221 &_swigt__p_wxPNMHandler,
60222 &_swigt__p_wxPaintEvent,
60223 &_swigt__p_wxPaletteChangedEvent,
60224 &_swigt__p_wxPaperSize,
60225 &_swigt__p_wxPoint,
60226 &_swigt__p_wxPoint2D,
60227 &_swigt__p_wxPropagateOnce,
60228 &_swigt__p_wxPropagationDisabler,
60229 &_swigt__p_wxPyApp,
60230 &_swigt__p_wxPyCommandEvent,
60231 &_swigt__p_wxPyDropTarget,
60232 &_swigt__p_wxPyEvent,
60233 &_swigt__p_wxPyFileSystemHandler,
60234 &_swigt__p_wxPyImageHandler,
60235 &_swigt__p_wxPyInputStream,
60236 &_swigt__p_wxPySizer,
60237 &_swigt__p_wxPyValidator,
60238 &_swigt__p_wxQuantize,
60239 &_swigt__p_wxQueryNewPaletteEvent,
60240 &_swigt__p_wxRealPoint,
60241 &_swigt__p_wxRect,
60242 &_swigt__p_wxRect2D,
60243 &_swigt__p_wxRegion,
60244 &_swigt__p_wxScrollEvent,
60245 &_swigt__p_wxScrollWinEvent,
60246 &_swigt__p_wxSetCursorEvent,
60247 &_swigt__p_wxShowEvent,
60248 &_swigt__p_wxSize,
60249 &_swigt__p_wxSizeEvent,
60250 &_swigt__p_wxSizer,
60251 &_swigt__p_wxSizerFlags,
60252 &_swigt__p_wxSizerItem,
60253 &_swigt__p_wxStaticBox,
60254 &_swigt__p_wxStaticBoxSizer,
60255 &_swigt__p_wxStdDialogButtonSizer,
60256 &_swigt__p_wxSysColourChangedEvent,
60257 &_swigt__p_wxTGAHandler,
60258 &_swigt__p_wxTIFFHandler,
60259 &_swigt__p_wxToolTip,
60260 &_swigt__p_wxUpdateUIEvent,
60261 &_swigt__p_wxValidator,
60262 &_swigt__p_wxVisualAttributes,
60263 &_swigt__p_wxWindow,
60264 &_swigt__p_wxWindowCreateEvent,
60265 &_swigt__p_wxWindowDestroyEvent,
60266 &_swigt__p_wxXPMHandler,
60267 &_swigt__p_wxZipFSHandler,
60268 };
60269
60270 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
60271 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
60272 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
60273 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
60274 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
60275 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
60276 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
60277 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
60278 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
60279 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
60280 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
60281 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
60282 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
60283 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
60284 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}};
60285 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
60286 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}};
60287 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
60288 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}};
60289 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
60290 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
60291 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
60292 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
60293 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
60294 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}};
60295 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
60296 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}};
60297 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
60298 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
60299 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
60300 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
60301 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
60302 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
60303 static swig_cast_info _swigc__p_wxDouble[] = { {&_swigt__p_wxDouble, 0, 0, 0},{0, 0, 0, 0}};
60304 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
60305 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
60306 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
60307 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}};
60308 static swig_cast_info _swigc__p_wxEventBlocker[] = { {&_swigt__p_wxEventBlocker, 0, 0, 0},{0, 0, 0, 0}};
60309 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
60310 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
60311 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}};
60312 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
60313 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
60314 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}};
60315 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}};
60316 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
60317 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
60318 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
60319 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
60320 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
60321 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
60322 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
60323 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
60324 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}};
60325 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
60326 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}};
60327 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
60328 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
60329 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
60330 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}};
60331 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
60332 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
60333 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
60334 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
60335 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
60336 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
60337 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
60338 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}};
60339 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
60340 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
60341 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
60342 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
60343 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
60344 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
60345 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
60346 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
60347 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
60348 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
60349 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
60350 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
60351 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
60352 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
60353 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
60354 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
60355 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
60356 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}};
60357 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
60358 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
60359 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
60360 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
60361 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
60362 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
60363 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
60364 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
60365 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
60366 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
60367 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
60368 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
60369 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
60370 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
60371 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
60372 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
60373 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
60374 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
60375 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
60376 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
60377 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
60378 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
60379 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
60380 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
60381 static swig_cast_info _swigc__p_wxRect2D[] = { {&_swigt__p_wxRect2D, 0, 0, 0},{0, 0, 0, 0}};
60382 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
60383 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
60384 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
60385 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
60386 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
60387 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
60388 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
60389 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}};
60390 static swig_cast_info _swigc__p_wxSizerFlags[] = { {&_swigt__p_wxSizerFlags, 0, 0, 0},{0, 0, 0, 0}};
60391 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}};
60392 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
60393 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
60394 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
60395 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
60396 static swig_cast_info _swigc__p_wxTGAHandler[] = { {&_swigt__p_wxTGAHandler, 0, 0, 0},{0, 0, 0, 0}};
60397 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
60398 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
60399 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
60400 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}};
60401 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
60402 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}};
60403 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
60404 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
60405 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
60406 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
60407
60408 static swig_cast_info *swig_cast_initial[] = {
60409 _swigc__p_buffer,
60410 _swigc__p_char,
60411 _swigc__p_form_ops_t,
60412 _swigc__p_int,
60413 _swigc__p_long,
60414 _swigc__p_unsigned_char,
60415 _swigc__p_unsigned_int,
60416 _swigc__p_unsigned_long,
60417 _swigc__p_wxANIHandler,
60418 _swigc__p_wxAcceleratorEntry,
60419 _swigc__p_wxAcceleratorTable,
60420 _swigc__p_wxActivateEvent,
60421 _swigc__p_wxAppTraits,
60422 _swigc__p_wxArrayString,
60423 _swigc__p_wxBMPHandler,
60424 _swigc__p_wxBitmap,
60425 _swigc__p_wxBoxSizer,
60426 _swigc__p_wxButton,
60427 _swigc__p_wxCURHandler,
60428 _swigc__p_wxCaret,
60429 _swigc__p_wxChildFocusEvent,
60430 _swigc__p_wxClipboardTextEvent,
60431 _swigc__p_wxCloseEvent,
60432 _swigc__p_wxColour,
60433 _swigc__p_wxCommandEvent,
60434 _swigc__p_wxContextMenuEvent,
60435 _swigc__p_wxControl,
60436 _swigc__p_wxControlWithItems,
60437 _swigc__p_wxCursor,
60438 _swigc__p_wxDC,
60439 _swigc__p_wxDateEvent,
60440 _swigc__p_wxDateTime,
60441 _swigc__p_wxDisplayChangedEvent,
60442 _swigc__p_wxDouble,
60443 _swigc__p_wxDropFilesEvent,
60444 _swigc__p_wxDuplexMode,
60445 _swigc__p_wxEraseEvent,
60446 _swigc__p_wxEvent,
60447 _swigc__p_wxEventBlocker,
60448 _swigc__p_wxEventLoop,
60449 _swigc__p_wxEventLoopActivator,
60450 _swigc__p_wxEvtHandler,
60451 _swigc__p_wxFSFile,
60452 _swigc__p_wxFileSystem,
60453 _swigc__p_wxFileSystemHandler,
60454 _swigc__p_wxFlexGridSizer,
60455 _swigc__p_wxFocusEvent,
60456 _swigc__p_wxFont,
60457 _swigc__p_wxFrame,
60458 _swigc__p_wxGBPosition,
60459 _swigc__p_wxGBSizerItem,
60460 _swigc__p_wxGBSpan,
60461 _swigc__p_wxGIFHandler,
60462 _swigc__p_wxGridBagSizer,
60463 _swigc__p_wxGridSizer,
60464 _swigc__p_wxHelpEvent__Origin,
60465 _swigc__p_wxICOHandler,
60466 _swigc__p_wxIconizeEvent,
60467 _swigc__p_wxIdleEvent,
60468 _swigc__p_wxImage,
60469 _swigc__p_wxImageHandler,
60470 _swigc__p_wxImageHistogram,
60471 _swigc__p_wxImage_HSVValue,
60472 _swigc__p_wxImage_RGBValue,
60473 _swigc__p_wxIndividualLayoutConstraint,
60474 _swigc__p_wxInitDialogEvent,
60475 _swigc__p_wxInputStream,
60476 _swigc__p_wxInternetFSHandler,
60477 _swigc__p_wxItemContainer,
60478 _swigc__p_wxJPEGHandler,
60479 _swigc__p_wxKeyEvent,
60480 _swigc__p_wxLayoutConstraints,
60481 _swigc__p_wxMaximizeEvent,
60482 _swigc__p_wxMemoryFSHandler,
60483 _swigc__p_wxMenu,
60484 _swigc__p_wxMenuBar,
60485 _swigc__p_wxMenuBarBase,
60486 _swigc__p_wxMenuEvent,
60487 _swigc__p_wxMenuItem,
60488 _swigc__p_wxMouseCaptureChangedEvent,
60489 _swigc__p_wxMouseCaptureLostEvent,
60490 _swigc__p_wxMouseEvent,
60491 _swigc__p_wxMoveEvent,
60492 _swigc__p_wxNavigationKeyEvent,
60493 _swigc__p_wxNcPaintEvent,
60494 _swigc__p_wxNotifyEvent,
60495 _swigc__p_wxObject,
60496 _swigc__p_wxOutputStream,
60497 _swigc__p_wxPCXHandler,
60498 _swigc__p_wxPNGHandler,
60499 _swigc__p_wxPNMHandler,
60500 _swigc__p_wxPaintEvent,
60501 _swigc__p_wxPaletteChangedEvent,
60502 _swigc__p_wxPaperSize,
60503 _swigc__p_wxPoint,
60504 _swigc__p_wxPoint2D,
60505 _swigc__p_wxPropagateOnce,
60506 _swigc__p_wxPropagationDisabler,
60507 _swigc__p_wxPyApp,
60508 _swigc__p_wxPyCommandEvent,
60509 _swigc__p_wxPyDropTarget,
60510 _swigc__p_wxPyEvent,
60511 _swigc__p_wxPyFileSystemHandler,
60512 _swigc__p_wxPyImageHandler,
60513 _swigc__p_wxPyInputStream,
60514 _swigc__p_wxPySizer,
60515 _swigc__p_wxPyValidator,
60516 _swigc__p_wxQuantize,
60517 _swigc__p_wxQueryNewPaletteEvent,
60518 _swigc__p_wxRealPoint,
60519 _swigc__p_wxRect,
60520 _swigc__p_wxRect2D,
60521 _swigc__p_wxRegion,
60522 _swigc__p_wxScrollEvent,
60523 _swigc__p_wxScrollWinEvent,
60524 _swigc__p_wxSetCursorEvent,
60525 _swigc__p_wxShowEvent,
60526 _swigc__p_wxSize,
60527 _swigc__p_wxSizeEvent,
60528 _swigc__p_wxSizer,
60529 _swigc__p_wxSizerFlags,
60530 _swigc__p_wxSizerItem,
60531 _swigc__p_wxStaticBox,
60532 _swigc__p_wxStaticBoxSizer,
60533 _swigc__p_wxStdDialogButtonSizer,
60534 _swigc__p_wxSysColourChangedEvent,
60535 _swigc__p_wxTGAHandler,
60536 _swigc__p_wxTIFFHandler,
60537 _swigc__p_wxToolTip,
60538 _swigc__p_wxUpdateUIEvent,
60539 _swigc__p_wxValidator,
60540 _swigc__p_wxVisualAttributes,
60541 _swigc__p_wxWindow,
60542 _swigc__p_wxWindowCreateEvent,
60543 _swigc__p_wxWindowDestroyEvent,
60544 _swigc__p_wxXPMHandler,
60545 _swigc__p_wxZipFSHandler,
60546 };
60547
60548
60549 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
60550
60551 static swig_const_info swig_const_table[] = {
60552 {0, 0, 0, 0.0, 0, 0}};
60553
60554 #ifdef __cplusplus
60555 }
60556 #endif
60557 /* -----------------------------------------------------------------------------
60558 * Type initialization:
60559 * This problem is tough by the requirement that no dynamic
60560 * memory is used. Also, since swig_type_info structures store pointers to
60561 * swig_cast_info structures and swig_cast_info structures store pointers back
60562 * to swig_type_info structures, we need some lookup code at initialization.
60563 * The idea is that swig generates all the structures that are needed.
60564 * The runtime then collects these partially filled structures.
60565 * The SWIG_InitializeModule function takes these initial arrays out of
60566 * swig_module, and does all the lookup, filling in the swig_module.types
60567 * array with the correct data and linking the correct swig_cast_info
60568 * structures together.
60569 *
60570 * The generated swig_type_info structures are assigned staticly to an initial
60571 * array. We just loop though that array, and handle each type individually.
60572 * First we lookup if this type has been already loaded, and if so, use the
60573 * loaded structure instead of the generated one. Then we have to fill in the
60574 * cast linked list. The cast data is initially stored in something like a
60575 * two-dimensional array. Each row corresponds to a type (there are the same
60576 * number of rows as there are in the swig_type_initial array). Each entry in
60577 * a column is one of the swig_cast_info structures for that type.
60578 * The cast_initial array is actually an array of arrays, because each row has
60579 * a variable number of columns. So to actually build the cast linked list,
60580 * we find the array of casts associated with the type, and loop through it
60581 * adding the casts to the list. The one last trick we need to do is making
60582 * sure the type pointer in the swig_cast_info struct is correct.
60583 *
60584 * First off, we lookup the cast->type name to see if it is already loaded.
60585 * There are three cases to handle:
60586 * 1) If the cast->type has already been loaded AND the type we are adding
60587 * casting info to has not been loaded (it is in this module), THEN we
60588 * replace the cast->type pointer with the type pointer that has already
60589 * been loaded.
60590 * 2) If BOTH types (the one we are adding casting info to, and the
60591 * cast->type) are loaded, THEN the cast info has already been loaded by
60592 * the previous module so we just ignore it.
60593 * 3) Finally, if cast->type has not already been loaded, then we add that
60594 * swig_cast_info to the linked list (because the cast->type) pointer will
60595 * be correct.
60596 * ----------------------------------------------------------------------------- */
60597
60598 #ifdef __cplusplus
60599 extern "C" {
60600 #if 0
60601 } /* c-mode */
60602 #endif
60603 #endif
60604
60605 #if 0
60606 #define SWIGRUNTIME_DEBUG
60607 #endif
60608
60609 SWIGRUNTIME void
60610 SWIG_InitializeModule(void *clientdata) {
60611 size_t i;
60612 swig_module_info *module_head;
60613 static int init_run = 0;
60614
60615 clientdata = clientdata;
60616
60617 if (init_run) return;
60618 init_run = 1;
60619
60620 /* Initialize the swig_module */
60621 swig_module.type_initial = swig_type_initial;
60622 swig_module.cast_initial = swig_cast_initial;
60623
60624 /* Try and load any already created modules */
60625 module_head = SWIG_GetModule(clientdata);
60626 if (module_head) {
60627 swig_module.next = module_head->next;
60628 module_head->next = &swig_module;
60629 } else {
60630 /* This is the first module loaded */
60631 swig_module.next = &swig_module;
60632 SWIG_SetModule(clientdata, &swig_module);
60633 }
60634
60635 /* Now work on filling in swig_module.types */
60636 #ifdef SWIGRUNTIME_DEBUG
60637 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
60638 #endif
60639 for (i = 0; i < swig_module.size; ++i) {
60640 swig_type_info *type = 0;
60641 swig_type_info *ret;
60642 swig_cast_info *cast;
60643
60644 #ifdef SWIGRUNTIME_DEBUG
60645 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
60646 #endif
60647
60648 /* if there is another module already loaded */
60649 if (swig_module.next != &swig_module) {
60650 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
60651 }
60652 if (type) {
60653 /* Overwrite clientdata field */
60654 #ifdef SWIGRUNTIME_DEBUG
60655 printf("SWIG_InitializeModule: found type %s\n", type->name);
60656 #endif
60657 if (swig_module.type_initial[i]->clientdata) {
60658 type->clientdata = swig_module.type_initial[i]->clientdata;
60659 #ifdef SWIGRUNTIME_DEBUG
60660 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
60661 #endif
60662 }
60663 } else {
60664 type = swig_module.type_initial[i];
60665 }
60666
60667 /* Insert casting types */
60668 cast = swig_module.cast_initial[i];
60669 while (cast->type) {
60670 /* Don't need to add information already in the list */
60671 ret = 0;
60672 #ifdef SWIGRUNTIME_DEBUG
60673 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
60674 #endif
60675 if (swig_module.next != &swig_module) {
60676 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
60677 #ifdef SWIGRUNTIME_DEBUG
60678 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
60679 #endif
60680 }
60681 if (ret) {
60682 if (type == swig_module.type_initial[i]) {
60683 #ifdef SWIGRUNTIME_DEBUG
60684 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
60685 #endif
60686 cast->type = ret;
60687 ret = 0;
60688 } else {
60689 /* Check for casting already in the list */
60690 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
60691 #ifdef SWIGRUNTIME_DEBUG
60692 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
60693 #endif
60694 if (!ocast) ret = 0;
60695 }
60696 }
60697
60698 if (!ret) {
60699 #ifdef SWIGRUNTIME_DEBUG
60700 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
60701 #endif
60702 if (type->cast) {
60703 type->cast->prev = cast;
60704 cast->next = type->cast;
60705 }
60706 type->cast = cast;
60707 }
60708 cast++;
60709 }
60710 /* Set entry in modules->types array equal to the type */
60711 swig_module.types[i] = type;
60712 }
60713 swig_module.types[i] = 0;
60714
60715 #ifdef SWIGRUNTIME_DEBUG
60716 printf("**** SWIG_InitializeModule: Cast List ******\n");
60717 for (i = 0; i < swig_module.size; ++i) {
60718 int j = 0;
60719 swig_cast_info *cast = swig_module.cast_initial[i];
60720 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
60721 while (cast->type) {
60722 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
60723 cast++;
60724 ++j;
60725 }
60726 printf("---- Total casts: %d\n",j);
60727 }
60728 printf("**** SWIG_InitializeModule: Cast List ******\n");
60729 #endif
60730 }
60731
60732 /* This function will propagate the clientdata field of type to
60733 * any new swig_type_info structures that have been added into the list
60734 * of equivalent types. It is like calling
60735 * SWIG_TypeClientData(type, clientdata) a second time.
60736 */
60737 SWIGRUNTIME void
60738 SWIG_PropagateClientData(void) {
60739 size_t i;
60740 swig_cast_info *equiv;
60741 static int init_run = 0;
60742
60743 if (init_run) return;
60744 init_run = 1;
60745
60746 for (i = 0; i < swig_module.size; i++) {
60747 if (swig_module.types[i]->clientdata) {
60748 equiv = swig_module.types[i]->cast;
60749 while (equiv) {
60750 if (!equiv->converter) {
60751 if (equiv->type && !equiv->type->clientdata)
60752 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
60753 }
60754 equiv = equiv->next;
60755 }
60756 }
60757 }
60758 }
60759
60760 #ifdef __cplusplus
60761 #if 0
60762 {
60763 /* c-mode */
60764 #endif
60765 }
60766 #endif
60767
60768
60769
60770 #ifdef __cplusplus
60771 extern "C" {
60772 #endif
60773
60774 /* Python-specific SWIG API */
60775 #define SWIG_newvarlink() SWIG_Python_newvarlink()
60776 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
60777 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
60778
60779 /* -----------------------------------------------------------------------------
60780 * global variable support code.
60781 * ----------------------------------------------------------------------------- */
60782
60783 typedef struct swig_globalvar {
60784 char *name; /* Name of global variable */
60785 PyObject *(*get_attr)(void); /* Return the current value */
60786 int (*set_attr)(PyObject *); /* Set the value */
60787 struct swig_globalvar *next;
60788 } swig_globalvar;
60789
60790 typedef struct swig_varlinkobject {
60791 PyObject_HEAD
60792 swig_globalvar *vars;
60793 } swig_varlinkobject;
60794
60795 SWIGINTERN PyObject *
60796 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
60797 return PyString_FromString("<Swig global variables>");
60798 }
60799
60800 SWIGINTERN PyObject *
60801 swig_varlink_str(swig_varlinkobject *v) {
60802 PyObject *str = PyString_FromString("(");
60803 swig_globalvar *var;
60804 for (var = v->vars; var; var=var->next) {
60805 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
60806 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
60807 }
60808 PyString_ConcatAndDel(&str,PyString_FromString(")"));
60809 return str;
60810 }
60811
60812 SWIGINTERN int
60813 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
60814 PyObject *str = swig_varlink_str(v);
60815 fprintf(fp,"Swig global variables ");
60816 fprintf(fp,"%s\n", PyString_AsString(str));
60817 Py_DECREF(str);
60818 return 0;
60819 }
60820
60821 SWIGINTERN void
60822 swig_varlink_dealloc(swig_varlinkobject *v) {
60823 swig_globalvar *var = v->vars;
60824 while (var) {
60825 swig_globalvar *n = var->next;
60826 free(var->name);
60827 free(var);
60828 var = n;
60829 }
60830 }
60831
60832 SWIGINTERN PyObject *
60833 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
60834 PyObject *res = NULL;
60835 swig_globalvar *var = v->vars;
60836 while (var) {
60837 if (strcmp(var->name,n) == 0) {
60838 res = (*var->get_attr)();
60839 break;
60840 }
60841 var = var->next;
60842 }
60843 if (res == NULL && !PyErr_Occurred()) {
60844 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
60845 }
60846 return res;
60847 }
60848
60849 SWIGINTERN int
60850 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
60851 int res = 1;
60852 swig_globalvar *var = v->vars;
60853 while (var) {
60854 if (strcmp(var->name,n) == 0) {
60855 res = (*var->set_attr)(p);
60856 break;
60857 }
60858 var = var->next;
60859 }
60860 if (res == 1 && !PyErr_Occurred()) {
60861 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
60862 }
60863 return res;
60864 }
60865
60866 SWIGINTERN PyTypeObject*
60867 swig_varlink_type(void) {
60868 static char varlink__doc__[] = "Swig var link object";
60869 static PyTypeObject varlink_type;
60870 static int type_init = 0;
60871 if (!type_init) {
60872 const PyTypeObject tmp
60873 = {
60874 PyObject_HEAD_INIT(NULL)
60875 0, /* Number of items in variable part (ob_size) */
60876 (char *)"swigvarlink", /* Type name (tp_name) */
60877 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
60878 0, /* Itemsize (tp_itemsize) */
60879 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
60880 (printfunc) swig_varlink_print, /* Print (tp_print) */
60881 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
60882 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
60883 0, /* tp_compare */
60884 (reprfunc) swig_varlink_repr, /* tp_repr */
60885 0, /* tp_as_number */
60886 0, /* tp_as_sequence */
60887 0, /* tp_as_mapping */
60888 0, /* tp_hash */
60889 0, /* tp_call */
60890 (reprfunc)swig_varlink_str, /* tp_str */
60891 0, /* tp_getattro */
60892 0, /* tp_setattro */
60893 0, /* tp_as_buffer */
60894 0, /* tp_flags */
60895 varlink__doc__, /* tp_doc */
60896 0, /* tp_traverse */
60897 0, /* tp_clear */
60898 0, /* tp_richcompare */
60899 0, /* tp_weaklistoffset */
60900 #if PY_VERSION_HEX >= 0x02020000
60901 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
60902 #endif
60903 #if PY_VERSION_HEX >= 0x02030000
60904 0, /* tp_del */
60905 #endif
60906 #ifdef COUNT_ALLOCS
60907 0,0,0,0 /* tp_alloc -> tp_next */
60908 #endif
60909 };
60910 varlink_type = tmp;
60911 varlink_type.ob_type = &PyType_Type;
60912 type_init = 1;
60913 }
60914 return &varlink_type;
60915 }
60916
60917 /* Create a variable linking object for use later */
60918 SWIGINTERN PyObject *
60919 SWIG_Python_newvarlink(void) {
60920 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
60921 if (result) {
60922 result->vars = 0;
60923 }
60924 return ((PyObject*) result);
60925 }
60926
60927 SWIGINTERN void
60928 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
60929 swig_varlinkobject *v = (swig_varlinkobject *) p;
60930 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
60931 if (gv) {
60932 size_t size = strlen(name)+1;
60933 gv->name = (char *)malloc(size);
60934 if (gv->name) {
60935 strncpy(gv->name,name,size);
60936 gv->get_attr = get_attr;
60937 gv->set_attr = set_attr;
60938 gv->next = v->vars;
60939 }
60940 }
60941 v->vars = gv;
60942 }
60943
60944 SWIGINTERN PyObject *
60945 SWIG_globals() {
60946 static PyObject *_SWIG_globals = 0;
60947 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
60948 return _SWIG_globals;
60949 }
60950
60951 /* -----------------------------------------------------------------------------
60952 * constants/methods manipulation
60953 * ----------------------------------------------------------------------------- */
60954
60955 /* Install Constants */
60956 SWIGINTERN void
60957 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
60958 PyObject *obj = 0;
60959 size_t i;
60960 for (i = 0; constants[i].type; ++i) {
60961 switch(constants[i].type) {
60962 case SWIG_PY_POINTER:
60963 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
60964 break;
60965 case SWIG_PY_BINARY:
60966 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
60967 break;
60968 default:
60969 obj = 0;
60970 break;
60971 }
60972 if (obj) {
60973 PyDict_SetItemString(d, constants[i].name, obj);
60974 Py_DECREF(obj);
60975 }
60976 }
60977 }
60978
60979 /* -----------------------------------------------------------------------------*/
60980 /* Fix SwigMethods to carry the callback ptrs when needed */
60981 /* -----------------------------------------------------------------------------*/
60982
60983 SWIGINTERN void
60984 SWIG_Python_FixMethods(PyMethodDef *methods,
60985 swig_const_info *const_table,
60986 swig_type_info **types,
60987 swig_type_info **types_initial) {
60988 size_t i;
60989 for (i = 0; methods[i].ml_name; ++i) {
60990 const char *c = methods[i].ml_doc;
60991 if (c && (c = strstr(c, "swig_ptr: "))) {
60992 int j;
60993 swig_const_info *ci = 0;
60994 const char *name = c + 10;
60995 for (j = 0; const_table[j].type; ++j) {
60996 if (strncmp(const_table[j].name, name,
60997 strlen(const_table[j].name)) == 0) {
60998 ci = &(const_table[j]);
60999 break;
61000 }
61001 }
61002 if (ci) {
61003 size_t shift = (ci->ptype) - types;
61004 swig_type_info *ty = types_initial[shift];
61005 size_t ldoc = (c - methods[i].ml_doc);
61006 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
61007 char *ndoc = (char*)malloc(ldoc + lptr + 10);
61008 if (ndoc) {
61009 char *buff = ndoc;
61010 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
61011 if (ptr) {
61012 strncpy(buff, methods[i].ml_doc, ldoc);
61013 buff += ldoc;
61014 strncpy(buff, "swig_ptr: ", 10);
61015 buff += 10;
61016 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
61017 methods[i].ml_doc = ndoc;
61018 }
61019 }
61020 }
61021 }
61022 }
61023 }
61024
61025 #ifdef __cplusplus
61026 }
61027 #endif
61028
61029 /* -----------------------------------------------------------------------------*
61030 * Partial Init method
61031 * -----------------------------------------------------------------------------*/
61032
61033 #ifdef __cplusplus
61034 extern "C"
61035 #endif
61036 SWIGEXPORT void SWIG_init(void) {
61037 PyObject *m, *d;
61038
61039 /* Fix SwigMethods to carry the callback ptrs when needed */
61040 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
61041
61042 m = Py_InitModule((char *) SWIG_name, SwigMethods);
61043 d = PyModule_GetDict(m);
61044
61045 SWIG_InitializeModule(0);
61046 SWIG_InstallConstants(d,swig_const_table);
61047
61048
61049
61050 #ifndef wxPyUSE_EXPORT
61051 // Make our API structure a CObject so other modules can import it
61052 // from this module.
61053 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
61054 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
61055 Py_XDECREF(cobj);
61056 #endif
61057
61058 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
61059 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
61060 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
61061 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
61062 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
61063 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
61064 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
61065 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
61066 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
61067 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
61068 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
61069 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
61070 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
61071 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
61072 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
61073 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
61074 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
61075 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
61076 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
61077 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
61078 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
61079 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
61080 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
61081 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
61082 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
61083 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
61084 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
61085 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
61086 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
61087 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
61088 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
61089 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
61090 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
61091 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
61092 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
61093 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
61094 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
61095 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
61096 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
61097 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
61098 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
61099 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
61100 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
61101 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
61102 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
61103 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
61104 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
61105 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
61106 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
61107 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
61108 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
61109 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
61110 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
61111 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
61112 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
61113 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
61114 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
61115 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
61116 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
61117 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
61118 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
61119 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
61120 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
61121 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
61122 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
61123 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
61124 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
61125 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
61126 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
61127 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
61128 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
61129 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
61130 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
61131 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
61132 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
61133 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
61134 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
61135 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
61136 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
61137 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
61138 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
61139 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
61140 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
61141 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
61142 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
61143 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
61144 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
61145 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
61146 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
61147 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
61148 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
61149 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
61150 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
61151 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
61152 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
61153 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
61154 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
61155 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
61156 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
61157 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
61158 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
61159 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
61160 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
61161 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
61162 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
61163 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
61164 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
61165 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
61166 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
61167 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
61168 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
61169 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
61170 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
61171 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
61172 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
61173 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
61174 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
61175 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
61176 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
61177 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
61178 SWIG_Python_SetConstant(d, "ID_EDIT",SWIG_From_int(static_cast< int >(wxID_EDIT)));
61179 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
61180 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
61181 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
61182 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
61183 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
61184 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
61185 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
61186 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
61187 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
61188 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
61189 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
61190 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
61191 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
61192 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
61193 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
61194 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
61195 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
61196 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
61197 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
61198 SWIG_Python_SetConstant(d, "ID_FILE",SWIG_From_int(static_cast< int >(wxID_FILE)));
61199 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
61200 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
61201 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
61202 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
61203 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
61204 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
61205 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
61206 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
61207 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
61208 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
61209 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
61210 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
61211 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
61212 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
61213 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
61214 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
61215 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
61216 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
61217 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
61218 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
61219 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
61220 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
61221 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
61222 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
61223 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
61224 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
61225 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
61226 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
61227 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
61228 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
61229 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
61230 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
61231 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
61232 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
61233 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
61234 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
61235 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
61236 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
61237 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
61238 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
61239 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
61240 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
61241 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
61242 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
61243 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
61244 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
61245 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
61246 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
61247 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
61248 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
61249 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
61250 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
61251 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
61252 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
61253 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
61254 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
61255 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
61256 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
61257 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
61258 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
61259 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
61260 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
61261 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
61262 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
61263 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
61264 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
61265 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
61266 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
61267 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
61268 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
61269 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
61270 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
61271 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
61272 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
61273 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
61274 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
61275 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
61276 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
61277 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
61278 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
61279 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
61280 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
61281 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
61282 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
61283 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
61284 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
61285 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
61286 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
61287 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
61288 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
61289 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
61290 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
61291 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
61292 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
61293 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
61294 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
61295 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
61296 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
61297 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
61298 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
61299 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
61300 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
61301 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
61302 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
61303 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
61304 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
61305 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
61306 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
61307 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
61308 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
61309 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
61310 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
61311 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
61312 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
61313 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
61314 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
61315 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
61316 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
61317 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
61318 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
61319 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
61320 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
61321 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
61322 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
61323 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
61324 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
61325 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
61326 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
61327 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
61328 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
61329 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
61330 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
61331 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
61332 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
61333 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
61334 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
61335 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
61336 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
61337 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
61338 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
61339 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
61340 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
61341 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
61342 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
61343 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
61344 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
61345 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
61346 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
61347 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
61348 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
61349 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
61350 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
61351 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
61352 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
61353 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
61354 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
61355 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
61356 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
61357 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
61358 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
61359 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
61360 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
61361 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
61362 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
61363 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
61364 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
61365 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
61366 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
61367 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
61368 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
61369 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
61370 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
61371 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
61372 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
61373 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
61374 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
61375 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
61376 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
61377 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
61378 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
61379 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
61380 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
61381 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
61382 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
61383 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
61384 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
61385 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
61386 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
61387 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
61388 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
61389 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
61390 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
61391 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
61392 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
61393 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
61394 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
61395 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
61396 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
61397 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
61398 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
61399 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
61400 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
61401 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
61402 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
61403 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
61404 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
61405 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
61406 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
61407 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
61408 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
61409 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
61410 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
61411 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
61412 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
61413 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
61414 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
61415 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
61416 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
61417 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
61418 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
61419 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
61420 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
61421 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
61422 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
61423 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
61424 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
61425 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
61426 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
61427 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
61428 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
61429 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
61430 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
61431 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
61432 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
61433 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
61434 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
61435 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
61436 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
61437 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
61438 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
61439 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
61440 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
61441 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
61442 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
61443 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
61444 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
61445 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
61446 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
61447 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
61448 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
61449 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
61450 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
61451 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
61452 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
61453 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
61454 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
61455 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
61456 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
61457 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
61458 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
61459 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
61460 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
61461 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
61462 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
61463 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
61464 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
61465 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
61466 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
61467 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
61468 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
61469 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
61470 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
61471 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
61472 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
61473 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
61474 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
61475 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
61476 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
61477 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
61478 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
61479 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
61480 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
61481 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
61482 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
61483 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
61484 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
61485 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
61486 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
61487 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
61488 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
61489 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
61490 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
61491 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
61492 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
61493 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
61494 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
61495 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
61496 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
61497 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
61498 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
61499 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
61500 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
61501 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
61502 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
61503 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
61504 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
61505 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
61506 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
61507 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
61508 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
61509 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
61510 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
61511 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
61512 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
61513 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
61514 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
61515 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
61516 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
61517 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
61518 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
61519 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
61520 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
61521 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
61522 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
61523 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
61524 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
61525 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
61526 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
61527 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
61528 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
61529 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
61530 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
61531 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
61532 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
61533 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
61534 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
61535 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
61536 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
61537 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
61538 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
61539 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
61540 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
61541 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
61542 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
61543 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
61544 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
61545 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
61546 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
61547 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
61548 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
61549 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
61550 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
61551 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
61552 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
61553 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
61554 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
61555 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
61556 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
61557 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
61558 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
61559 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
61560 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
61561 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
61562 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
61563 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
61564 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
61565 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
61566 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
61567 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
61568 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
61569 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
61570 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
61571 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
61572 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
61573 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
61574 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
61575 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
61576 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
61577 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
61578 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
61579 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
61580 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
61581 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
61582 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
61583 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
61584 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
61585 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
61586 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
61587 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
61588 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
61589 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
61590 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
61591 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
61592 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
61593 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
61594 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
61595 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
61596 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
61597 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
61598 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
61599 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
61600 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
61601 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
61602 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
61603 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
61604 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
61605 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
61606 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
61607 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
61608 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
61609 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
61610 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
61611 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
61612 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
61613 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
61614 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
61615 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
61616 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
61617 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
61618 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
61619 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
61620 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
61621 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
61622 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
61623 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
61624 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
61625 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
61626 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
61627 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
61628 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
61629 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
61630 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
61631 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
61632 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
61633 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
61634 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
61635 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
61636 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
61637 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
61638 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
61639 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
61640 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
61641 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
61642 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
61643 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
61644 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
61645 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
61646 SWIG_Python_SetConstant(d, "Layout_Default",SWIG_From_int(static_cast< int >(wxLayout_Default)));
61647 SWIG_Python_SetConstant(d, "Layout_LeftToRight",SWIG_From_int(static_cast< int >(wxLayout_LeftToRight)));
61648 SWIG_Python_SetConstant(d, "Layout_RightToLeft",SWIG_From_int(static_cast< int >(wxLayout_RightToLeft)));
61649 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
61650 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
61651 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
61652 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
61653 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
61654 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
61655 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
61656 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
61657 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
61658 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
61659 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
61660 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
61661 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
61662 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
61663 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
61664 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
61665 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
61666 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
61667 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
61668 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
61669 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TGA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TGA)));
61670 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
61671 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
61672 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
61673 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
61674 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
61675 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
61676 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
61677 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
61678 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
61679 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
61680 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
61681 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
61682 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
61683 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
61684 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
61685 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
61686 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
61687 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
61688 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
61689 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
61690 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
61691 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
61692 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
61693 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
61694 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
61695 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
61696 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
61697 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
61698 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
61699 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
61700 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
61701 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
61702 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
61703 SWIG_Python_SetConstant(d, "Inside",SWIG_From_int(static_cast< int >(wxInside)));
61704 SWIG_Python_SetConstant(d, "OutLeft",SWIG_From_int(static_cast< int >(wxOutLeft)));
61705 SWIG_Python_SetConstant(d, "OutRight",SWIG_From_int(static_cast< int >(wxOutRight)));
61706 SWIG_Python_SetConstant(d, "OutTop",SWIG_From_int(static_cast< int >(wxOutTop)));
61707 SWIG_Python_SetConstant(d, "OutBottom",SWIG_From_int(static_cast< int >(wxOutBottom)));
61708 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
61709 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
61710 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
61711 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
61712 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
61713
61714 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
61715
61716
61717 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
61718
61719 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
61720 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
61721 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
61722 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_NORMAL",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_NORMAL)));
61723 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_HIGH)));
61724 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
61725 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
61726 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
61727 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
61728 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
61729 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
61730 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
61731 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
61732 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
61733 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
61734 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
61735 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
61736 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
61737 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
61738 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
61739 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
61740 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
61741 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
61742 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
61743 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
61744 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
61745 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
61746 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
61747 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
61748 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
61749 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
61750 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
61751 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
61752 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
61753 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
61754 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
61755 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
61756 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
61757 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
61758 PyDict_SetItemString(d, "wxEVT_ANY", PyInt_FromLong(wxEVT_ANY));
61759 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
61760 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
61761 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
61762 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
61763 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
61764 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
61765 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
61766 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
61767 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
61768 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
61769 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
61770 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
61771 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
61772 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
61773 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
61774 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
61775 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
61776 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
61777 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
61778 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
61779 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
61780 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
61781 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
61782 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
61783 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
61784 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
61785 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
61786 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
61787 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
61788 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
61789 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
61790 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
61791 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
61792 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
61793 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
61794 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
61795 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
61796 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
61797 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
61798 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
61799 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
61800 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
61801 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
61802 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
61803 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
61804 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
61805 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
61806 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
61807 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
61808 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
61809 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
61810 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
61811 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
61812 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
61813 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
61814 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
61815 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
61816 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
61817 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
61818 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
61819 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
61820 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
61821 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
61822 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
61823 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
61824 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
61825 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
61826 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
61827 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
61828 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
61829 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
61830 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
61831 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
61832 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
61833 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
61834 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
61835 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
61836 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
61837 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
61838 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
61839 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
61840 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
61841 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
61842 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
61843 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
61844 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
61845 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
61846 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
61847 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
61848 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
61849 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
61850 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
61851 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
61852 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
61853 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
61854 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
61855 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
61856 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
61857 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
61858 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
61859 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
61860 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
61861 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
61862 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
61863 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
61864 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
61865 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
61866 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
61867 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
61868 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
61869 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
61870 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
61871 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
61872 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
61873 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
61874 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
61875 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
61876 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
61877 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
61878 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
61879 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
61880 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
61881 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
61882 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
61883 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
61884 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
61885 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
61886 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
61887 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
61888 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
61889 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
61890 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
61891 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
61892 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
61893 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
61894 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
61895 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
61896 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
61897 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
61898 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
61899 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
61900 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
61901 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
61902 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
61903 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
61904 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
61905 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
61906 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
61907 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
61908 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
61909 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
61910 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
61911 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
61912 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
61913 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
61914 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
61915 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
61916 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
61917 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
61918 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
61919 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
61920 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
61921 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
61922 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
61923 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
61924 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
61925 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
61926 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
61927 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
61928 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
61929 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
61930 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
61931 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
61932 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
61933 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
61934
61935 // Initialize threading, some globals and such
61936 __wxPyPreStart(d);
61937
61938
61939 // Although these are defined in __version__ they need to be here too so
61940 // that an assert can be done to ensure that the wxPython and the wxWindows
61941 // versions match.
61942 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
61943 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
61944 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
61945
61946 }
61947
wxWidgets (Impactor)