]> 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
[ 1521481 ] wxPathList modernization
[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_wxDropFilesEvent swig_types[33]
2500 #define SWIGTYPE_p_wxDuplexMode swig_types[34]
2501 #define SWIGTYPE_p_wxEraseEvent swig_types[35]
2502 #define SWIGTYPE_p_wxEvent swig_types[36]
2503 #define SWIGTYPE_p_wxEventLoop swig_types[37]
2504 #define SWIGTYPE_p_wxEventLoopActivator swig_types[38]
2505 #define SWIGTYPE_p_wxEvtHandler swig_types[39]
2506 #define SWIGTYPE_p_wxFSFile swig_types[40]
2507 #define SWIGTYPE_p_wxFileSystem swig_types[41]
2508 #define SWIGTYPE_p_wxFileSystemHandler swig_types[42]
2509 #define SWIGTYPE_p_wxFlexGridSizer swig_types[43]
2510 #define SWIGTYPE_p_wxFocusEvent swig_types[44]
2511 #define SWIGTYPE_p_wxFont swig_types[45]
2512 #define SWIGTYPE_p_wxFrame swig_types[46]
2513 #define SWIGTYPE_p_wxGBPosition swig_types[47]
2514 #define SWIGTYPE_p_wxGBSizerItem swig_types[48]
2515 #define SWIGTYPE_p_wxGBSpan swig_types[49]
2516 #define SWIGTYPE_p_wxGIFHandler swig_types[50]
2517 #define SWIGTYPE_p_wxGridBagSizer swig_types[51]
2518 #define SWIGTYPE_p_wxGridSizer swig_types[52]
2519 #define SWIGTYPE_p_wxHelpEvent__Origin swig_types[53]
2520 #define SWIGTYPE_p_wxICOHandler swig_types[54]
2521 #define SWIGTYPE_p_wxIconizeEvent swig_types[55]
2522 #define SWIGTYPE_p_wxIdleEvent swig_types[56]
2523 #define SWIGTYPE_p_wxImage swig_types[57]
2524 #define SWIGTYPE_p_wxImageHandler swig_types[58]
2525 #define SWIGTYPE_p_wxImageHistogram swig_types[59]
2526 #define SWIGTYPE_p_wxImage_HSVValue swig_types[60]
2527 #define SWIGTYPE_p_wxImage_RGBValue swig_types[61]
2528 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[62]
2529 #define SWIGTYPE_p_wxInitDialogEvent swig_types[63]
2530 #define SWIGTYPE_p_wxInputStream swig_types[64]
2531 #define SWIGTYPE_p_wxInternetFSHandler swig_types[65]
2532 #define SWIGTYPE_p_wxItemContainer swig_types[66]
2533 #define SWIGTYPE_p_wxJPEGHandler swig_types[67]
2534 #define SWIGTYPE_p_wxKeyEvent swig_types[68]
2535 #define SWIGTYPE_p_wxLayoutConstraints swig_types[69]
2536 #define SWIGTYPE_p_wxMaximizeEvent swig_types[70]
2537 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[71]
2538 #define SWIGTYPE_p_wxMenu swig_types[72]
2539 #define SWIGTYPE_p_wxMenuBar swig_types[73]
2540 #define SWIGTYPE_p_wxMenuBarBase swig_types[74]
2541 #define SWIGTYPE_p_wxMenuEvent swig_types[75]
2542 #define SWIGTYPE_p_wxMenuItem swig_types[76]
2543 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[77]
2544 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[78]
2545 #define SWIGTYPE_p_wxMouseEvent swig_types[79]
2546 #define SWIGTYPE_p_wxMoveEvent swig_types[80]
2547 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[81]
2548 #define SWIGTYPE_p_wxNcPaintEvent swig_types[82]
2549 #define SWIGTYPE_p_wxNotifyEvent swig_types[83]
2550 #define SWIGTYPE_p_wxObject swig_types[84]
2551 #define SWIGTYPE_p_wxOutputStream swig_types[85]
2552 #define SWIGTYPE_p_wxPCXHandler swig_types[86]
2553 #define SWIGTYPE_p_wxPNGHandler swig_types[87]
2554 #define SWIGTYPE_p_wxPNMHandler swig_types[88]
2555 #define SWIGTYPE_p_wxPaintEvent swig_types[89]
2556 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[90]
2557 #define SWIGTYPE_p_wxPaperSize swig_types[91]
2558 #define SWIGTYPE_p_wxPoint swig_types[92]
2559 #define SWIGTYPE_p_wxPoint2D swig_types[93]
2560 #define SWIGTYPE_p_wxPropagateOnce swig_types[94]
2561 #define SWIGTYPE_p_wxPropagationDisabler swig_types[95]
2562 #define SWIGTYPE_p_wxPyApp swig_types[96]
2563 #define SWIGTYPE_p_wxPyCommandEvent swig_types[97]
2564 #define SWIGTYPE_p_wxPyDropTarget swig_types[98]
2565 #define SWIGTYPE_p_wxPyEvent swig_types[99]
2566 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[100]
2567 #define SWIGTYPE_p_wxPyImageHandler swig_types[101]
2568 #define SWIGTYPE_p_wxPyInputStream swig_types[102]
2569 #define SWIGTYPE_p_wxPySizer swig_types[103]
2570 #define SWIGTYPE_p_wxPyValidator swig_types[104]
2571 #define SWIGTYPE_p_wxQuantize swig_types[105]
2572 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[106]
2573 #define SWIGTYPE_p_wxRealPoint swig_types[107]
2574 #define SWIGTYPE_p_wxRect swig_types[108]
2575 #define SWIGTYPE_p_wxRegion swig_types[109]
2576 #define SWIGTYPE_p_wxScrollEvent swig_types[110]
2577 #define SWIGTYPE_p_wxScrollWinEvent swig_types[111]
2578 #define SWIGTYPE_p_wxSetCursorEvent swig_types[112]
2579 #define SWIGTYPE_p_wxShowEvent swig_types[113]
2580 #define SWIGTYPE_p_wxSize swig_types[114]
2581 #define SWIGTYPE_p_wxSizeEvent swig_types[115]
2582 #define SWIGTYPE_p_wxSizer swig_types[116]
2583 #define SWIGTYPE_p_wxSizerItem swig_types[117]
2584 #define SWIGTYPE_p_wxStaticBox swig_types[118]
2585 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[119]
2586 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[120]
2587 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[121]
2588 #define SWIGTYPE_p_wxTIFFHandler swig_types[122]
2589 #define SWIGTYPE_p_wxToolTip swig_types[123]
2590 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[124]
2591 #define SWIGTYPE_p_wxValidator swig_types[125]
2592 #define SWIGTYPE_p_wxVisualAttributes swig_types[126]
2593 #define SWIGTYPE_p_wxWindow swig_types[127]
2594 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[128]
2595 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[129]
2596 #define SWIGTYPE_p_wxXPMHandler swig_types[130]
2597 #define SWIGTYPE_p_wxZipFSHandler swig_types[131]
2598 static swig_type_info *swig_types[133];
2599 static swig_module_info swig_module = {swig_types, 132, 0, 0, 0, 0};
2600 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2601 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2602
2603 /* -------- TYPES TABLE (END) -------- */
2604
2605 #if (PY_VERSION_HEX <= 0x02000000)
2606 # if !defined(SWIG_PYTHON_CLASSIC)
2607 # error "This python version requires to use swig with the '-classic' option"
2608 # endif
2609 #endif
2610 #if (PY_VERSION_HEX <= 0x02020000)
2611 # error "This python version requires to use swig with the '-nomodern' option"
2612 #endif
2613 #if (PY_VERSION_HEX <= 0x02020000)
2614 # error "This python version requires to use swig with the '-nomodernargs' option"
2615 #endif
2616 #ifndef METH_O
2617 # error "This python version requires to use swig with the '-nofastunpack' option"
2618 #endif
2619
2620 /*-----------------------------------------------
2621 @(target):= _core_.so
2622 ------------------------------------------------*/
2623 #define SWIG_init init_core_
2624
2625 #define SWIG_name "_core_"
2626
2627 #define SWIGVERSION 0x010329
2628
2629
2630 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2631 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2632
2633
2634 #include <stdexcept>
2635
2636
2637 namespace swig {
2638 class PyObject_ptr {
2639 protected:
2640 PyObject *_obj;
2641
2642 public:
2643 PyObject_ptr() :_obj(0)
2644 {
2645 }
2646
2647 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2648 {
2649 Py_XINCREF(_obj);
2650 }
2651
2652 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2653 {
2654 if (initial_ref) Py_XINCREF(_obj);
2655 }
2656
2657 PyObject_ptr & operator=(const PyObject_ptr& item)
2658 {
2659 Py_XINCREF(item._obj);
2660 Py_XDECREF(_obj);
2661 _obj = item._obj;
2662 return *this;
2663 }
2664
2665 ~PyObject_ptr()
2666 {
2667 Py_XDECREF(_obj);
2668 }
2669
2670 operator PyObject *() const
2671 {
2672 return _obj;
2673 }
2674
2675 PyObject *operator->() const
2676 {
2677 return _obj;
2678 }
2679 };
2680 }
2681
2682
2683 namespace swig {
2684 struct PyObject_var : PyObject_ptr {
2685 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2686
2687 PyObject_var & operator = (PyObject* obj)
2688 {
2689 Py_XDECREF(_obj);
2690 _obj = obj;
2691 return *this;
2692 }
2693 };
2694 }
2695
2696
2697 #include "wx/wxPython/wxPython_int.h"
2698 #include "wx/wxPython/pyclasses.h"
2699 #include "wx/wxPython/twoitem.h"
2700
2701
2702 #ifndef wxPyUSE_EXPORT
2703 // Helper functions for dealing with SWIG objects and such. These are
2704 // located here so they know about the SWIG types and functions declared
2705 // in the wrapper code.
2706
2707 #include <wx/hashmap.h>
2708 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2709
2710
2711 // Maintains a hashmap of className to swig_type_info pointers. Given the
2712 // name of a class either looks up the type info in the cache, or scans the
2713 // SWIG tables for it.
2714 extern PyObject* wxPyPtrTypeMap;
2715 static
2716 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2717
2718 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2719
2720 if (typeInfoCache == NULL)
2721 typeInfoCache = new wxPyTypeInfoHashMap;
2722
2723 wxString name(className);
2724 swig_type_info* swigType = (*typeInfoCache)[name];
2725
2726 if (! swigType) {
2727 // it wasn't in the cache, so look it up from SWIG
2728 name.Append(wxT(" *"));
2729 swigType = SWIG_TypeQuery(name.mb_str());
2730
2731 // if it still wasn't found, try looking for a mapped name
2732 if (!swigType) {
2733 PyObject* item;
2734 name = className;
2735
2736 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2737 (char*)(const char*)name.mbc_str())) != NULL) {
2738 name = wxString(PyString_AsString(item), *wxConvCurrent);
2739 name.Append(wxT(" *"));
2740 swigType = SWIG_TypeQuery(name.mb_str());
2741 }
2742 }
2743 if (swigType) {
2744 // and add it to the map if found
2745 (*typeInfoCache)[className] = swigType;
2746 }
2747 }
2748 return swigType;
2749 }
2750
2751
2752 // Check if a class name is a type known to SWIG
2753 bool wxPyCheckSwigType(const wxChar* className) {
2754
2755 swig_type_info* swigType = wxPyFindSwigType(className);
2756 return swigType != NULL;
2757 }
2758
2759
2760 // Given a pointer to a C++ object and a class name, construct a Python proxy
2761 // object for it.
2762 PyObject* wxPyConstructObject(void* ptr,
2763 const wxChar* className,
2764 int setThisOwn) {
2765
2766 swig_type_info* swigType = wxPyFindSwigType(className);
2767 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2768
2769 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2770 }
2771
2772
2773 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2774 // Ensures that the proxy object is of the specified (or derived) type. If
2775 // not able to perform the conversion then a Python exception is set and the
2776 // error should be handled properly in the caller. Returns True on success.
2777 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2778 const wxChar* className) {
2779
2780 swig_type_info* swigType = wxPyFindSwigType(className);
2781 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2782
2783 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2784 }
2785
2786
2787
2788 // Make a SWIGified pointer object suitable for a .this attribute
2789 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2790
2791 PyObject* robj = NULL;
2792
2793 swig_type_info* swigType = wxPyFindSwigType(className);
2794 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2795
2796 robj = PySwigObject_New(ptr, swigType, 0);
2797 return robj;
2798 }
2799
2800
2801 // Python's PyInstance_Check does not return True for instances of new-style
2802 // classes. This should get close enough for both new and old classes but I
2803 // should re-evaluate the need for doing instance checks...
2804 bool wxPyInstance_Check(PyObject* obj) {
2805 return PyObject_HasAttrString(obj, "__class__") != 0;
2806 }
2807
2808
2809 // This one checks if the object is an instance of a SWIG proxy class (it has
2810 // a .this attribute, and the .this attribute is a PySwigObject.)
2811 bool wxPySwigInstance_Check(PyObject* obj) {
2812 static PyObject* this_str = NULL;
2813 if (this_str == NULL)
2814 this_str = PyString_FromString("this");
2815
2816 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2817 if (this_attr) {
2818 bool retval = (PySwigObject_Check(this_attr) != 0);
2819 Py_DECREF(this_attr);
2820 return retval;
2821 }
2822
2823 PyErr_Clear();
2824 return false;
2825 }
2826
2827
2828 // Export a C API in a struct. Other modules will be able to load this from
2829 // the wx._core_ module and will then have safe access to these functions,
2830 // even if they are located in another shared library.
2831 static wxPyCoreAPI API = {
2832
2833 wxPyCheckSwigType,
2834 wxPyConstructObject,
2835 wxPyConvertSwigPtr,
2836 wxPyMakeSwigPtr,
2837
2838 wxPyBeginAllowThreads,
2839 wxPyEndAllowThreads,
2840 wxPyBeginBlockThreads,
2841 wxPyEndBlockThreads,
2842
2843 wxPy_ConvertList,
2844
2845 wxString_in_helper,
2846 Py2wxString,
2847 wx2PyString,
2848
2849 byte_LIST_helper,
2850 int_LIST_helper,
2851 long_LIST_helper,
2852 string_LIST_helper,
2853 wxPoint_LIST_helper,
2854 wxBitmap_LIST_helper,
2855 wxString_LIST_helper,
2856 wxAcceleratorEntry_LIST_helper,
2857
2858 wxSize_helper,
2859 wxPoint_helper,
2860 wxRealPoint_helper,
2861 wxRect_helper,
2862 wxColour_helper,
2863 wxPoint2D_helper,
2864
2865 wxPySimple_typecheck,
2866 wxColour_typecheck,
2867
2868 wxPyCBH_setCallbackInfo,
2869 wxPyCBH_findCallback,
2870 wxPyCBH_callCallback,
2871 wxPyCBH_callCallbackObj,
2872 wxPyCBH_delete,
2873
2874 wxPyMake_wxObject,
2875 wxPyMake_wxSizer,
2876 wxPyPtrTypeMap_Add,
2877 wxPy2int_seq_helper,
2878 wxPy4int_seq_helper,
2879 wxArrayString2PyList_helper,
2880 wxArrayInt2PyList_helper,
2881
2882 wxPyClientData_dtor,
2883 wxPyUserData_dtor,
2884 wxPyOORClientData_dtor,
2885
2886 wxPyCBInputStream_create,
2887 wxPyCBInputStream_copy,
2888
2889 wxPyInstance_Check,
2890 wxPySwigInstance_Check,
2891
2892 wxPyCheckForApp
2893
2894 };
2895
2896 #endif
2897
2898
2899 #if !WXWIN_COMPATIBILITY_2_4
2900 #define wxHIDE_READONLY 0
2901 #endif
2902
2903
2904 #define SWIG_From_long PyInt_FromLong
2905
2906
2907 SWIGINTERNINLINE PyObject *
2908 SWIG_From_int (int value)
2909 {
2910 return SWIG_From_long (value);
2911 }
2912
2913 static const wxString wxPyEmptyString(wxEmptyString);
2914 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2915 return self->GetClassInfo()->GetClassName();
2916 }
2917 SWIGINTERN void wxObject_Destroy(wxObject *self){
2918 delete self;
2919 }
2920
2921 #ifndef __WXMAC__
2922 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2923 #endif
2924
2925
2926 #include <limits.h>
2927 #ifndef LLONG_MIN
2928 # define LLONG_MIN LONG_LONG_MIN
2929 #endif
2930 #ifndef LLONG_MAX
2931 # define LLONG_MAX LONG_LONG_MAX
2932 #endif
2933 #ifndef ULLONG_MAX
2934 # define ULLONG_MAX ULONG_LONG_MAX
2935 #endif
2936
2937
2938 SWIGINTERN int
2939 SWIG_AsVal_long (PyObject* obj, long* val)
2940 {
2941 if (PyNumber_Check(obj)) {
2942 if (val) *val = PyInt_AsLong(obj);
2943 return SWIG_OK;
2944 }
2945 return SWIG_TypeError;
2946 }
2947
2948
2949 SWIGINTERN int
2950 SWIG_AsVal_int (PyObject * obj, int *val)
2951 {
2952 long v;
2953 int res = SWIG_AsVal_long (obj, &v);
2954 if (SWIG_IsOK(res)) {
2955 if ((v < INT_MIN || v > INT_MAX)) {
2956 return SWIG_OverflowError;
2957 } else {
2958 if (val) *val = static_cast< int >(v);
2959 }
2960 }
2961 return res;
2962 }
2963
2964 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2965 wxSize temp, *obj = &temp;
2966 if ( other == Py_None ) return false;
2967 if ( ! wxSize_helper(other, &obj) ) {
2968 PyErr_Clear();
2969 return false;
2970 }
2971 return self->operator==(*obj);
2972 }
2973 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2974 wxSize temp, *obj = &temp;
2975 if ( other == Py_None ) return true;
2976 if ( ! wxSize_helper(other, &obj)) {
2977 PyErr_Clear();
2978 return true;
2979 }
2980 return self->operator!=(*obj);
2981 }
2982
2983 #include <float.h>
2984
2985
2986 SWIGINTERN int
2987 SWIG_AsVal_double (PyObject *obj, double* val)
2988 {
2989 if (PyNumber_Check(obj)) {
2990 if (val) *val = PyFloat_AsDouble(obj);
2991 return SWIG_OK;
2992 }
2993 return SWIG_TypeError;
2994 }
2995
2996
2997 SWIGINTERN int
2998 SWIG_AsVal_float (PyObject * obj, float *val)
2999 {
3000 double v;
3001 int res = SWIG_AsVal_double (obj, &v);
3002 if (SWIG_IsOK(res)) {
3003 if ((v < -FLT_MAX || v > FLT_MAX)) {
3004 return SWIG_OverflowError;
3005 } else {
3006 if (val) *val = static_cast< float >(v);
3007 }
3008 }
3009 return res;
3010 }
3011
3012 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
3013 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3014 PyObject* tup = PyTuple_New(2);
3015 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3016 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3017 wxPyEndBlockThreads(blocked);
3018 return tup;
3019 }
3020
3021 #define SWIG_From_double PyFloat_FromDouble
3022
3023 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3024 wxRealPoint temp, *obj = &temp;
3025 if ( other == Py_None ) return false;
3026 if ( ! wxRealPoint_helper(other, &obj) ) {
3027 PyErr_Clear();
3028 return false;
3029 }
3030 return self->operator==(*obj);
3031 }
3032 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3033 wxRealPoint temp, *obj = &temp;
3034 if ( other == Py_None ) return true;
3035 if ( ! wxRealPoint_helper(other, &obj)) {
3036 PyErr_Clear();
3037 return true;
3038 }
3039 return self->operator!=(*obj);
3040 }
3041 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3042 self->x = x;
3043 self->y = y;
3044 }
3045 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3046 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3047 PyObject* tup = PyTuple_New(2);
3048 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3049 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3050 wxPyEndBlockThreads(blocked);
3051 return tup;
3052 }
3053 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3054 wxPoint temp, *obj = &temp;
3055 if ( other == Py_None ) return false;
3056 if ( ! wxPoint_helper(other, &obj) ) {
3057 PyErr_Clear();
3058 return false;
3059 }
3060 return self->operator==(*obj);
3061 }
3062 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3063 wxPoint temp, *obj = &temp;
3064 if ( other == Py_None ) return true;
3065 if ( ! wxPoint_helper(other, &obj)) {
3066 PyErr_Clear();
3067 return true;
3068 }
3069 return self->operator!=(*obj);
3070 }
3071 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3072 self->x = x;
3073 self->y = y;
3074 }
3075 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3076 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3077 PyObject* tup = PyTuple_New(2);
3078 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3079 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3080 wxPyEndBlockThreads(blocked);
3081 return tup;
3082 }
3083 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3084 wxRect temp, *obj = &temp;
3085 if ( other == Py_None ) return false;
3086 if ( ! wxRect_helper(other, &obj) ) {
3087 PyErr_Clear();
3088 return false;
3089 }
3090 return self->operator==(*obj);
3091 }
3092 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3093 wxRect temp, *obj = &temp;
3094 if ( other == Py_None ) return true;
3095 if ( ! wxRect_helper(other, &obj)) {
3096 PyErr_Clear();
3097 return true;
3098 }
3099 return self->operator!=(*obj);
3100 }
3101 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3102 self->x = x;
3103 self->y = y;
3104 self->width = width;
3105 self->height = height;
3106 }
3107 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3108 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3109 PyObject* tup = PyTuple_New(4);
3110 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3111 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3112 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3113 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3114 wxPyEndBlockThreads(blocked);
3115 return tup;
3116 }
3117
3118 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3119 wxRegion reg1(*r1);
3120 wxRegion reg2(*r2);
3121 wxRect dest(0,0,0,0);
3122 PyObject* obj;
3123
3124 reg1.Intersect(reg2);
3125 dest = reg1.GetBox();
3126
3127 if (dest != wxRect(0,0,0,0)) {
3128 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3129 wxRect* newRect = new wxRect(dest);
3130 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3131 wxPyEndBlockThreads(blocked);
3132 return obj;
3133 }
3134 Py_INCREF(Py_None);
3135 return Py_None;
3136 }
3137
3138 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3139 wxPoint2D temp, *obj = &temp;
3140 if ( other == Py_None ) return false;
3141 if ( ! wxPoint2D_helper(other, &obj) ) {
3142 PyErr_Clear();
3143 return false;
3144 }
3145 return self->operator==(*obj);
3146 }
3147 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3148 wxPoint2D temp, *obj = &temp;
3149 if ( other == Py_None ) return true;
3150 if ( ! wxPoint2D_helper(other, &obj)) {
3151 PyErr_Clear();
3152 return true;
3153 }
3154 return self->operator!=(*obj);
3155 }
3156 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3157 self->m_x = x;
3158 self->m_y = y;
3159 }
3160 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3161 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3162 PyObject* tup = PyTuple_New(2);
3163 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3164 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3165 wxPyEndBlockThreads(blocked);
3166 return tup;
3167 }
3168
3169 #include "wx/wxPython/pyistream.h"
3170
3171 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3172 wxInputStream* wxis = wxPyCBInputStream::create(p);
3173 if (wxis)
3174 return new wxPyInputStream(wxis);
3175 else
3176 return NULL;
3177 }
3178
3179 SWIGINTERN swig_type_info*
3180 SWIG_pchar_descriptor()
3181 {
3182 static int init = 0;
3183 static swig_type_info* info = 0;
3184 if (!init) {
3185 info = SWIG_TypeQuery("_p_char");
3186 init = 1;
3187 }
3188 return info;
3189 }
3190
3191
3192 SWIGINTERNINLINE PyObject *
3193 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3194 {
3195 if (carray) {
3196 if (size > INT_MAX) {
3197 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3198 return pchar_descriptor ?
3199 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3200 } else {
3201 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3202 }
3203 } else {
3204 return SWIG_Py_Void();
3205 }
3206 }
3207
3208
3209 SWIGINTERNINLINE PyObject *
3210 SWIG_From_char (char c)
3211 {
3212 return SWIG_FromCharPtrAndSize(&c,1);
3213 }
3214
3215
3216 SWIGINTERNINLINE PyObject*
3217 SWIG_From_unsigned_SS_long (unsigned long value)
3218 {
3219 return (value > LONG_MAX) ?
3220 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3221 }
3222
3223
3224 SWIGINTERNINLINE PyObject *
3225 SWIG_From_size_t (size_t value)
3226 {
3227 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3228 }
3229
3230
3231 SWIGINTERN int
3232 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3233 {
3234 if (PyString_Check(obj)) {
3235 char *cstr; Py_ssize_t len;
3236 PyString_AsStringAndSize(obj, &cstr, &len);
3237 if (cptr) {
3238 if (alloc) {
3239 /*
3240 In python the user should not be able to modify the inner
3241 string representation. To warranty that, if you define
3242 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3243 buffer is always returned.
3244
3245 The default behavior is just to return the pointer value,
3246 so, be careful.
3247 */
3248 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3249 if (*alloc != SWIG_OLDOBJ)
3250 #else
3251 if (*alloc == SWIG_NEWOBJ)
3252 #endif
3253 {
3254 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3255 *alloc = SWIG_NEWOBJ;
3256 }
3257 else {
3258 *cptr = cstr;
3259 *alloc = SWIG_OLDOBJ;
3260 }
3261 } else {
3262 *cptr = PyString_AsString(obj);
3263 }
3264 }
3265 if (psize) *psize = len + 1;
3266 return SWIG_OK;
3267 } else {
3268 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3269 if (pchar_descriptor) {
3270 void* vptr = 0;
3271 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3272 if (cptr) *cptr = (char *) vptr;
3273 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3274 if (alloc) *alloc = SWIG_OLDOBJ;
3275 return SWIG_OK;
3276 }
3277 }
3278 }
3279 return SWIG_TypeError;
3280 }
3281
3282
3283 SWIGINTERN int
3284 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3285 {
3286 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3287 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3288 if (SWIG_IsOK(res)) {
3289 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3290 if (csize <= size) {
3291 if (val) {
3292 if (csize) memcpy(val, cptr, csize*sizeof(char));
3293 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3294 }
3295 if (alloc == SWIG_NEWOBJ) {
3296 delete[] cptr;
3297 res = SWIG_DelNewMask(res);
3298 }
3299 return res;
3300 }
3301 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3302 }
3303 return SWIG_TypeError;
3304 }
3305
3306
3307 SWIGINTERN int
3308 SWIG_AsVal_char (PyObject * obj, char *val)
3309 {
3310 int res = SWIG_AsCharArray(obj, val, 1);
3311 if (!SWIG_IsOK(res)) {
3312 long v;
3313 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3314 if (SWIG_IsOK(res)) {
3315 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3316 if (val) *val = static_cast< char >(v);
3317 } else {
3318 res = SWIG_OverflowError;
3319 }
3320 }
3321 }
3322 return res;
3323 }
3324
3325 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3326 // We use only strings for the streams, not unicode
3327 PyObject* str = PyObject_Str(obj);
3328 if (! str) {
3329 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3330 return;
3331 }
3332 self->Write(PyString_AS_STRING(str),
3333 PyString_GET_SIZE(str));
3334 Py_DECREF(str);
3335 }
3336
3337 #include "wx/wxPython/pyistream.h"
3338
3339
3340 class wxPyFileSystemHandler : public wxFileSystemHandler
3341 {
3342 public:
3343 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3344
3345 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3346 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3347 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3348 DEC_PYCALLBACK_STRING__pure(FindNext);
3349
3350 wxString GetProtocol(const wxString& location) {
3351 return wxFileSystemHandler::GetProtocol(location);
3352 }
3353
3354 wxString GetLeftLocation(const wxString& location) {
3355 return wxFileSystemHandler::GetLeftLocation(location);
3356 }
3357
3358 wxString GetAnchor(const wxString& location) {
3359 return wxFileSystemHandler::GetAnchor(location);
3360 }
3361
3362 wxString GetRightLocation(const wxString& location) {
3363 return wxFileSystemHandler::GetRightLocation(location);
3364 }
3365
3366 wxString GetMimeTypeFromExt(const wxString& location) {
3367 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3368 }
3369
3370 PYPRIVATE;
3371 };
3372
3373
3374 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3375 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3376 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3377 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3378
3379
3380 SWIGINTERN int
3381 SWIG_AsVal_bool (PyObject *obj, bool *val)
3382 {
3383 if (obj == Py_True) {
3384 if (val) *val = true;
3385 return SWIG_OK;
3386 } else if (obj == Py_False) {
3387 if (val) *val = false;
3388 return SWIG_OK;
3389 } else {
3390 long v = 0;
3391 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3392 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3393 return res;
3394 }
3395 }
3396
3397 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3398 wxFileName fname = wxFileSystem::URLToFileName(url);
3399 return fname.GetFullPath();
3400 }
3401
3402 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3403 wxImage& image,
3404 long type) {
3405 wxMemoryFSHandler::AddFile(filename, image, type);
3406 }
3407
3408 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3409 const wxBitmap& bitmap,
3410 long type) {
3411 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3412 }
3413
3414 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3415 PyObject* data) {
3416 if (! PyString_Check(data)) {
3417 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3418 "Expected string object"));
3419 return;
3420 }
3421
3422 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3423 void* ptr = (void*)PyString_AsString(data);
3424 size_t size = PyString_Size(data);
3425 wxPyEndBlockThreads(blocked);
3426
3427 wxMemoryFSHandler::AddFile(filename, ptr, size);
3428 }
3429
3430
3431 #include "wx/wxPython/pyistream.h"
3432
3433
3434 SWIGINTERN int
3435 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3436 {
3437 long v = 0;
3438 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3439 return SWIG_TypeError;
3440 }
3441 else if (val)
3442 *val = (unsigned long)v;
3443 return SWIG_OK;
3444 }
3445
3446
3447 SWIGINTERN int
3448 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3449 {
3450 unsigned long v;
3451 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3452 if (SWIG_IsOK(res)) {
3453 if ((v > UCHAR_MAX)) {
3454 return SWIG_OverflowError;
3455 } else {
3456 if (val) *val = static_cast< unsigned char >(v);
3457 }
3458 }
3459 return res;
3460 }
3461
3462
3463 SWIGINTERNINLINE PyObject *
3464 SWIG_From_unsigned_SS_char (unsigned char value)
3465 {
3466 return SWIG_From_unsigned_SS_long (value);
3467 }
3468
3469 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3470 wxImageHistogramEntry e = (*self)[key];
3471 return e.value;
3472 }
3473 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3474 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3475 wxImageHistogramEntry e = (*self)[key];
3476 return e.value;
3477 }
3478 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3479 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3480 colour.Green(),
3481 colour.Blue());
3482 wxImageHistogramEntry e = (*self)[key];
3483 return e.value;
3484 }
3485
3486 // Pull the nested class out to the top level for SWIG's sake
3487 #define wxImage_RGBValue wxImage::RGBValue
3488 #define wxImage_HSVValue wxImage::HSVValue
3489
3490 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3491 if (width > 0 && height > 0)
3492 return new wxImage(width, height, clear);
3493 else
3494 return new wxImage;
3495 }
3496 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3497 return new wxImage(bitmap.ConvertToImage());
3498 }
3499 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3500 if (DATASIZE != width*height*3) {
3501 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3502 return NULL;
3503 }
3504
3505 // Copy the source data so the wxImage can clean it up later
3506 buffer copy = (buffer)malloc(DATASIZE);
3507 if (copy == NULL) {
3508 wxPyBLOCK_THREADS(PyErr_NoMemory());
3509 return NULL;
3510 }
3511 memcpy(copy, data, DATASIZE);
3512 return new wxImage(width, height, copy, false);
3513 }
3514 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3515 if (DATASIZE != width*height*3) {
3516 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3517 return NULL;
3518 }
3519 if (ALPHASIZE != width*height) {
3520 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3521 return NULL;
3522 }
3523
3524 // Copy the source data so the wxImage can clean it up later
3525 buffer dcopy = (buffer)malloc(DATASIZE);
3526 if (dcopy == NULL) {
3527 wxPyBLOCK_THREADS(PyErr_NoMemory());
3528 return NULL;
3529 }
3530 memcpy(dcopy, data, DATASIZE);
3531
3532 buffer acopy = (buffer)malloc(ALPHASIZE);
3533 if (acopy == NULL) {
3534 wxPyBLOCK_THREADS(PyErr_NoMemory());
3535 return NULL;
3536 }
3537 memcpy(acopy, alpha, ALPHASIZE);
3538
3539 return new wxImage(width, height, dcopy, acopy, false);
3540 }
3541 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3542 wxSize size(self->GetWidth(), self->GetHeight());
3543 return size;
3544 }
3545 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3546 buffer data = self->GetData();
3547 int len = self->GetWidth() * self->GetHeight() * 3;
3548 PyObject* rv;
3549 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3550 return rv;
3551 }
3552 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3553 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3554 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3555 return;
3556 }
3557 buffer copy = (buffer)malloc(DATASIZE);
3558 if (copy == NULL) {
3559 wxPyBLOCK_THREADS(PyErr_NoMemory());
3560 return;
3561 }
3562 memcpy(copy, data, DATASIZE);
3563 self->SetData(copy, false);
3564 // wxImage takes ownership of copy...
3565 }
3566 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3567 buffer data = self->GetData();
3568 int len = self->GetWidth() * self->GetHeight() * 3;
3569 PyObject* rv;
3570 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3571 return rv;
3572 }
3573 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3574 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3575 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3576 return;
3577 }
3578 self->SetData(data, true);
3579 }
3580 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3581 buffer data = self->GetAlpha();
3582 if (! data) {
3583 RETURN_NONE();
3584 } else {
3585 int len = self->GetWidth() * self->GetHeight();
3586 PyObject* rv;
3587 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3588 return rv;
3589 }
3590 }
3591 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3592 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3593 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3594 return;
3595 }
3596 buffer acopy = (buffer)malloc(ALPHASIZE);
3597 if (acopy == NULL) {
3598 wxPyBLOCK_THREADS(PyErr_NoMemory());
3599 return;
3600 }
3601 memcpy(acopy, alpha, ALPHASIZE);
3602 self->SetAlpha(acopy, false);
3603 // wxImage takes ownership of acopy...
3604 }
3605 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3606 buffer data = self->GetAlpha();
3607 int len = self->GetWidth() * self->GetHeight();
3608 PyObject* rv;
3609 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3610 return rv;
3611 }
3612 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3613 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3614 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3615 return;
3616 }
3617 self->SetAlpha(alpha, true);
3618 }
3619 SWIGINTERN PyObject *wxImage_GetHandlers(){
3620 wxList& list = wxImage::GetHandlers();
3621 return wxPy_ConvertList(&list);
3622 }
3623 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3624 wxBitmap bitmap(*self, depth);
3625 return bitmap;
3626 }
3627 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3628 wxImage mono = self->ConvertToMono( red, green, blue );
3629 wxBitmap bitmap( mono, 1 );
3630 return bitmap;
3631 }
3632
3633 wxImage* _ImageFromBuffer(int width, int height,
3634 buffer data, int DATASIZE,
3635 buffer alpha=NULL, int ALPHASIZE=0)
3636 {
3637 if (DATASIZE != width*height*3) {
3638 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3639 return NULL;
3640 }
3641 if (alpha != NULL) {
3642 if (ALPHASIZE != width*height) {
3643 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3644 return NULL;
3645 }
3646 return new wxImage(width, height, data, alpha, true);
3647 }
3648 return new wxImage(width, height, data, true);
3649 }
3650
3651 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3652 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3653 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3654 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3655 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3656 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3657 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3658 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3659 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3660 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3661 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3662 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3663 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3664 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3665 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3666
3667 #include <wx/quantize.h>
3668
3669 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3670 return wxQuantize::Quantize(src, dest,
3671 //NULL, // palette
3672 desiredNoColours,
3673 NULL, // eightBitData
3674 flags);
3675 }
3676 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3677 if (PyCallable_Check(func)) {
3678 self->Connect(id, lastId, eventType,
3679 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3680 new wxPyCallback(func));
3681 }
3682 else if (func == Py_None) {
3683 self->Disconnect(id, lastId, eventType,
3684 (wxObjectEventFunction)
3685 &wxPyCallback::EventThunker);
3686 }
3687 else {
3688 wxPyBLOCK_THREADS(
3689 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3690 }
3691 }
3692 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3693 return self->Disconnect(id, lastId, eventType,
3694 (wxObjectEventFunction)
3695 &wxPyCallback::EventThunker);
3696 }
3697 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3698 if (_self && _self != Py_None) {
3699 self->SetClientObject(new wxPyOORClientData(_self, incref));
3700 }
3701 else {
3702 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3703 if (data) {
3704 self->SetClientObject(NULL); // This will delete it too
3705 }
3706 }
3707 }
3708
3709 #if ! wxUSE_HOTKEY
3710 #define wxEVT_HOTKEY -9999
3711 #endif
3712
3713 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3714 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3715 if (data) {
3716 Py_INCREF(data->m_obj);
3717 return data->m_obj;
3718 } else {
3719 Py_INCREF(Py_None);
3720 return Py_None;
3721 }
3722 }
3723 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3724 wxPyClientData* data = new wxPyClientData(clientData);
3725 self->SetClientObject(data);
3726 }
3727 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3728 #if wxUSE_UNICODE
3729 return self->GetUnicodeKey();
3730 #else
3731 return 0;
3732 #endif
3733 }
3734 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3735 #if wxUSE_UNICODE
3736 self->m_uniChar = uniChar;
3737 #endif
3738 }
3739
3740 SWIGINTERNINLINE PyObject *
3741 SWIG_From_unsigned_SS_int (unsigned int value)
3742 {
3743 return SWIG_From_unsigned_SS_long (value);
3744 }
3745
3746
3747 SWIGINTERN int
3748 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3749 {
3750 unsigned long v;
3751 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3752 if (SWIG_IsOK(res)) {
3753 if ((v > UINT_MAX)) {
3754 return SWIG_OverflowError;
3755 } else {
3756 if (val) *val = static_cast< unsigned int >(v);
3757 }
3758 }
3759 return res;
3760 }
3761
3762 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3763 self->m_size = size;
3764 }
3765 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3766 int count = self->GetNumberOfFiles();
3767 wxString* files = self->GetFiles();
3768 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3769 PyObject* list = PyList_New(count);
3770
3771 if (!list) {
3772 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3773 wxPyEndBlockThreads(blocked);
3774 return NULL;
3775 }
3776
3777 for (int i=0; i<count; i++) {
3778 PyList_SetItem(list, i, wx2PyString(files[i]));
3779 }
3780 wxPyEndBlockThreads(blocked);
3781 return list;
3782 }
3783
3784
3785 SWIGINTERN wxPyApp *new_wxPyApp(){
3786 wxPythonApp = new wxPyApp();
3787 return wxPythonApp;
3788 }
3789 SWIGINTERN int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
3790 SWIGINTERN bool wxPyApp_IsDisplayAvailable(){
3791 return wxPyTestDisplayAvailable();
3792 }
3793
3794 void wxApp_CleanUp() {
3795 __wxPyCleanup();
3796 }
3797
3798
3799 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3800
3801
3802
3803
3804
3805 SWIGINTERNINLINE PyObject *
3806 SWIG_FromCharPtr(const char *cptr)
3807 {
3808 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3809 }
3810
3811
3812 #if 0 // #ifdef __WXMAC__
3813
3814 // A dummy class that raises an exception if used...
3815 class wxEventLoop
3816 {
3817 public:
3818 wxEventLoop() { wxPyRaiseNotImplemented(); }
3819 int Run() { return 0; }
3820 void Exit(int rc = 0) {}
3821 bool Pending() const { return false; }
3822 bool Dispatch() { return false; }
3823 bool IsRunning() const { return false; }
3824 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3825 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3826 };
3827
3828 #else
3829
3830 #include <wx/evtloop.h>
3831
3832 #endif
3833
3834
3835
3836 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3837 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3838 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3839 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3840 wxWindowList& list = self->GetChildren();
3841 return wxPy_ConvertList(&list);
3842 }
3843 SWIGINTERN void wxWindow_SetDoubleBuffered(wxWindow *self,bool on){}
3844 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3845 #if wxUSE_HOTKEY
3846 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3847 #else
3848 return false;
3849 #endif
3850 }
3851 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3852
3853
3854
3855 return false;
3856
3857 }
3858 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3859 return wxPyGetWinHandle(self);
3860 }
3861 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3862 self->AssociateHandle((WXWidget)handle);
3863 }
3864 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3865
3866 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3867 return wxWindow::FindWindowById(id, parent);
3868 }
3869
3870 wxWindow* wxFindWindowByName( const wxString& name,
3871 const wxWindow *parent = NULL ) {
3872 return wxWindow::FindWindowByName(name, parent);
3873 }
3874
3875 wxWindow* wxFindWindowByLabel( const wxString& label,
3876 const wxWindow *parent = NULL ) {
3877 return wxWindow::FindWindowByLabel(label, parent);
3878 }
3879
3880
3881 #ifdef __WXMSW__
3882 #include <wx/msw/private.h> // to get wxGetWindowId
3883 #endif
3884
3885
3886 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3887 #ifdef __WXMSW__
3888 WXHWND hWnd = (WXHWND)_hWnd;
3889 long id = wxGetWindowId(hWnd);
3890 wxWindow* win = new wxWindow;
3891 if (parent)
3892 parent->AddChild(win);
3893 win->SetEventHandler(win);
3894 win->SetHWND(hWnd);
3895 win->SetId(id);
3896 win->SubclassWin(hWnd);
3897 win->AdoptAttributesFromHWND();
3898 win->SetupColours();
3899 return win;
3900 #else
3901 wxPyRaiseNotImplemented();
3902 return NULL;
3903 #endif
3904 }
3905
3906
3907 PyObject* GetTopLevelWindows() {
3908 return wxPy_ConvertList(&wxTopLevelWindows);
3909 }
3910
3911
3912 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3913 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3914 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3915
3916 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3917
3918
3919 SWIGINTERNINLINE int
3920 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3921 {
3922 unsigned long v;
3923 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3924 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3925 return res;
3926 }
3927
3928 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3929 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3930 wxMenuItemList& list = self->GetMenuItems();
3931 return wxPy_ConvertList(&list);
3932 }
3933 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
3934 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
3935 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
3936 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
3937 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
3938 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
3939 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
3940 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
3941 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
3942 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
3943 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
3944 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
3945 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
3946 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
3947 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
3948 static const wxString wxPyControlNameStr(wxControlNameStr);
3949 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3950 if (clientData) {
3951 wxPyClientData* data = new wxPyClientData(clientData);
3952 return self->Append(item, data);
3953 } else
3954 return self->Append(item);
3955 }
3956 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3957 if (clientData) {
3958 wxPyClientData* data = new wxPyClientData(clientData);
3959 return self->Insert(item, pos, data);
3960 } else
3961 return self->Insert(item, pos);
3962 }
3963 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3964 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3965 if (data) {
3966 Py_INCREF(data->m_obj);
3967 return data->m_obj;
3968 } else {
3969 Py_INCREF(Py_None);
3970 return Py_None;
3971 }
3972 }
3973 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3974 wxPyClientData* data = new wxPyClientData(clientData);
3975 self->SetClientObject(n, data);
3976 }
3977
3978
3979 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3980 wxPyUserData* data = NULL;
3981 if ( userData ) {
3982 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3983 data = new wxPyUserData(userData);
3984 wxPyEndBlockThreads(blocked);
3985 }
3986 return new wxSizerItem(window, proportion, flag, border, data);
3987 }
3988 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3989 wxPyUserData* data = NULL;
3990 if ( userData ) {
3991 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3992 data = new wxPyUserData(userData);
3993 wxPyEndBlockThreads(blocked);
3994 }
3995 return new wxSizerItem(width, height, proportion, flag, border, data);
3996 }
3997 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
3998 wxPyUserData* data = NULL;
3999 if ( userData ) {
4000 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4001 data = new wxPyUserData(userData);
4002 wxPyEndBlockThreads(blocked);
4003 }
4004 return new wxSizerItem(sizer, proportion, flag, border, data);
4005 }
4006
4007 SWIGINTERNINLINE PyObject *
4008 SWIG_From_float (float value)
4009 {
4010 return SWIG_From_double (value);
4011 }
4012
4013 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
4014 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
4015 if (data) {
4016 Py_INCREF(data->m_obj);
4017 return data->m_obj;
4018 } else {
4019 Py_INCREF(Py_None);
4020 return Py_None;
4021 }
4022 }
4023 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4024 wxPyUserData* data = NULL;
4025 if ( userData ) {
4026 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4027 data = new wxPyUserData(userData);
4028 wxPyEndBlockThreads(blocked);
4029 }
4030 self->SetUserData(data);
4031 }
4032
4033 // Figure out the type of the sizer item
4034
4035 struct wxPySizerItemInfo {
4036 wxPySizerItemInfo()
4037 : window(NULL), sizer(NULL), gotSize(false),
4038 size(wxDefaultSize), gotPos(false), pos(-1)
4039 {}
4040
4041 wxWindow* window;
4042 wxSizer* sizer;
4043 bool gotSize;
4044 wxSize size;
4045 bool gotPos;
4046 int pos;
4047 };
4048
4049 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4050
4051 wxPySizerItemInfo info;
4052 wxSize size;
4053 wxSize* sizePtr = &size;
4054
4055 // Find out what the type of the item is
4056 // try wxWindow
4057 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4058 PyErr_Clear();
4059 info.window = NULL;
4060
4061 // try wxSizer
4062 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4063 PyErr_Clear();
4064 info.sizer = NULL;
4065
4066 // try wxSize or (w,h)
4067 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4068 info.size = *sizePtr;
4069 info.gotSize = true;
4070 }
4071
4072 // or a single int
4073 if (checkIdx && PyInt_Check(item)) {
4074 info.pos = PyInt_AsLong(item);
4075 info.gotPos = true;
4076 }
4077 }
4078 }
4079
4080 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4081 // no expected type, figure out what kind of error message to generate
4082 if ( !checkSize && !checkIdx )
4083 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4084 else if ( checkSize && !checkIdx )
4085 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4086 else if ( !checkSize && checkIdx)
4087 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4088 else
4089 // can this one happen?
4090 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4091 }
4092
4093 return info;
4094 }
4095
4096 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4097 if (!self->GetClientObject())
4098 self->SetClientObject(new wxPyOORClientData(_self));
4099 }
4100 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4101
4102 wxPyUserData* data = NULL;
4103 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4104 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4105 if ( userData && (info.window || info.sizer || info.gotSize) )
4106 data = new wxPyUserData(userData);
4107 if ( info.sizer )
4108 PyObject_SetAttrString(item,"thisown",Py_False);
4109 wxPyEndBlockThreads(blocked);
4110
4111 // Now call the real Add method if a valid item type was found
4112 if ( info.window )
4113 return self->Add(info.window, proportion, flag, border, data);
4114 else if ( info.sizer )
4115 return self->Add(info.sizer, proportion, flag, border, data);
4116 else if (info.gotSize)
4117 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4118 proportion, flag, border, data);
4119 else
4120 return NULL;
4121 }
4122 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4123
4124 wxPyUserData* data = NULL;
4125 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4126 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4127 if ( userData && (info.window || info.sizer || info.gotSize) )
4128 data = new wxPyUserData(userData);
4129 if ( info.sizer )
4130 PyObject_SetAttrString(item,"thisown",Py_False);
4131 wxPyEndBlockThreads(blocked);
4132
4133 // Now call the real Insert method if a valid item type was found
4134 if ( info.window )
4135 return self->Insert(before, info.window, proportion, flag, border, data);
4136 else if ( info.sizer )
4137 return self->Insert(before, info.sizer, proportion, flag, border, data);
4138 else if (info.gotSize)
4139 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4140 proportion, flag, border, data);
4141 else
4142 return NULL;
4143 }
4144 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4145
4146 wxPyUserData* data = NULL;
4147 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4148 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4149 if ( userData && (info.window || info.sizer || info.gotSize) )
4150 data = new wxPyUserData(userData);
4151 if ( info.sizer )
4152 PyObject_SetAttrString(item,"thisown",Py_False);
4153 wxPyEndBlockThreads(blocked);
4154
4155 // Now call the real Prepend method if a valid item type was found
4156 if ( info.window )
4157 return self->Prepend(info.window, proportion, flag, border, data);
4158 else if ( info.sizer )
4159 return self->Prepend(info.sizer, proportion, flag, border, data);
4160 else if (info.gotSize)
4161 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4162 proportion, flag, border, data);
4163 else
4164 return NULL;
4165 }
4166 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4167 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4168 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4169 wxPyEndBlockThreads(blocked);
4170 if ( info.window )
4171 return self->Remove(info.window);
4172 else if ( info.sizer )
4173 return self->Remove(info.sizer);
4174 else if ( info.gotPos )
4175 return self->Remove(info.pos);
4176 else
4177 return false;
4178 }
4179 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4180 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4181 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4182 wxPyEndBlockThreads(blocked);
4183 if ( info.window )
4184 return self->Detach(info.window);
4185 else if ( info.sizer )
4186 return self->Detach(info.sizer);
4187 else if ( info.gotPos )
4188 return self->Detach(info.pos);
4189 else
4190 return false;
4191 }
4192 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4193 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4194 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4195 wxPyEndBlockThreads(blocked);
4196 if ( info.window )
4197 return self->GetItem(info.window);
4198 else if ( info.sizer )
4199 return self->GetItem(info.sizer);
4200 else if ( info.gotPos )
4201 return self->GetItem(info.pos);
4202 else
4203 return NULL;
4204 }
4205 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4206 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4207 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4208 wxPyEndBlockThreads(blocked);
4209 if ( info.window )
4210 self->SetItemMinSize(info.window, size);
4211 else if ( info.sizer )
4212 self->SetItemMinSize(info.sizer, size);
4213 else if ( info.gotPos )
4214 self->SetItemMinSize(info.pos, size);
4215 }
4216 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4217 wxSizerItemList& list = self->GetChildren();
4218 return wxPy_ConvertList(&list);
4219 }
4220 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4221 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4222 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4223 wxPyEndBlockThreads(blocked);
4224 if ( info.window )
4225 return self->Show(info.window, show, recursive);
4226 else if ( info.sizer )
4227 return self->Show(info.sizer, show, recursive);
4228 else if ( info.gotPos )
4229 return self->Show(info.pos, show);
4230 else
4231 return false;
4232 }
4233 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4234 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4235 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4236 wxPyEndBlockThreads(blocked);
4237 if ( info.window )
4238 return self->IsShown(info.window);
4239 else if ( info.sizer )
4240 return self->IsShown(info.sizer);
4241 else if ( info.gotPos )
4242 return self->IsShown(info.pos);
4243 else
4244 return false;
4245 }
4246
4247 // See pyclasses.h
4248 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4249 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4250 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4251
4252
4253
4254
4255 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4256 {
4257 if (source == Py_None) {
4258 **obj = wxGBPosition(-1,-1);
4259 return true;
4260 }
4261 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4262 }
4263
4264 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4265 {
4266 if (source == Py_None) {
4267 **obj = wxGBSpan(-1,-1);
4268 return true;
4269 }
4270 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4271 }
4272
4273
4274 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4275 wxGBPosition temp, *obj = &temp;
4276 if ( other == Py_None ) return false;
4277 if ( ! wxGBPosition_helper(other, &obj) ) {
4278 PyErr_Clear();
4279 return false;
4280 }
4281 return self->operator==(*obj);
4282 }
4283 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4284 wxGBPosition temp, *obj = &temp;
4285 if ( other == Py_None ) return true;
4286 if ( ! wxGBPosition_helper(other, &obj)) {
4287 PyErr_Clear();
4288 return true;
4289 }
4290 return self->operator!=(*obj);
4291 }
4292 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4293 self->SetRow(row);
4294 self->SetCol(col);
4295 }
4296 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4297 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4298 PyObject* tup = PyTuple_New(2);
4299 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4300 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4301 wxPyEndBlockThreads(blocked);
4302 return tup;
4303 }
4304 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4305 wxGBSpan temp, *obj = &temp;
4306 if ( other == Py_None ) return false;
4307 if ( ! wxGBSpan_helper(other, &obj) ) {
4308 PyErr_Clear();
4309 return false;
4310 }
4311 return self->operator==(*obj);
4312 }
4313 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4314 wxGBSpan temp, *obj = &temp;
4315 if ( other == Py_None ) return true;
4316 if ( ! wxGBSpan_helper(other, &obj)) {
4317 PyErr_Clear();
4318 return true;
4319 }
4320 return self->operator!=(*obj);
4321 }
4322 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4323 self->SetRowspan(rowspan);
4324 self->SetColspan(colspan);
4325 }
4326 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4327 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4328 PyObject* tup = PyTuple_New(2);
4329 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4330 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4331 wxPyEndBlockThreads(blocked);
4332 return tup;
4333 }
4334 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4335 wxPyUserData* data = NULL;
4336 if ( userData ) {
4337 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4338 data = new wxPyUserData(userData);
4339 wxPyEndBlockThreads(blocked);
4340 }
4341 return new wxGBSizerItem(window, pos, span, flag, border, data);
4342 }
4343 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4344 wxPyUserData* data = NULL;
4345 if ( userData ) {
4346 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4347 data = new wxPyUserData(userData);
4348 wxPyEndBlockThreads(blocked);
4349 }
4350 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4351 }
4352 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4353 wxPyUserData* data = NULL;
4354 if ( userData ) {
4355 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4356 data = new wxPyUserData(userData);
4357 wxPyEndBlockThreads(blocked);
4358 }
4359 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4360 }
4361 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4362 int row, col;
4363 self->GetEndPos(row, col);
4364 return wxGBPosition(row, col);
4365 }
4366 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4367
4368 wxPyUserData* data = NULL;
4369 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4370 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4371 if ( userData && (info.window || info.sizer || info.gotSize) )
4372 data = new wxPyUserData(userData);
4373 if ( info.sizer )
4374 PyObject_SetAttrString(item,"thisown",Py_False);
4375 wxPyEndBlockThreads(blocked);
4376
4377 // Now call the real Add method if a valid item type was found
4378 if ( info.window )
4379 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4380 else if ( info.sizer )
4381 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4382 else if (info.gotSize)
4383 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4384 pos, span, flag, border, data);
4385 return NULL;
4386 }
4387
4388
4389 #ifdef __cplusplus
4390 extern "C" {
4391 #endif
4392 SWIGINTERN int EmptyString_set(PyObject *) {
4393 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4394 return 1;
4395 }
4396
4397
4398 SWIGINTERN PyObject *EmptyString_get(void) {
4399 PyObject *pyobj = 0;
4400
4401 {
4402 #if wxUSE_UNICODE
4403 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4404 #else
4405 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4406 #endif
4407 }
4408 return pyobj;
4409 }
4410
4411
4412 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4413 PyObject *resultobj = 0;
4414 wxObject *arg1 = (wxObject *) 0 ;
4415 wxString result;
4416 void *argp1 = 0 ;
4417 int res1 = 0 ;
4418 PyObject *swig_obj[1] ;
4419
4420 if (!args) SWIG_fail;
4421 swig_obj[0] = args;
4422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4423 if (!SWIG_IsOK(res1)) {
4424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4425 }
4426 arg1 = reinterpret_cast< wxObject * >(argp1);
4427 {
4428 PyThreadState* __tstate = wxPyBeginAllowThreads();
4429 result = wxObject_GetClassName(arg1);
4430 wxPyEndAllowThreads(__tstate);
4431 if (PyErr_Occurred()) SWIG_fail;
4432 }
4433 {
4434 #if wxUSE_UNICODE
4435 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4436 #else
4437 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4438 #endif
4439 }
4440 return resultobj;
4441 fail:
4442 return NULL;
4443 }
4444
4445
4446 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4447 PyObject *resultobj = 0;
4448 wxObject *arg1 = (wxObject *) 0 ;
4449 void *argp1 = 0 ;
4450 int res1 = 0 ;
4451 PyObject *swig_obj[1] ;
4452
4453 if (!args) SWIG_fail;
4454 swig_obj[0] = args;
4455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4456 if (!SWIG_IsOK(res1)) {
4457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4458 }
4459 arg1 = reinterpret_cast< wxObject * >(argp1);
4460 {
4461 PyThreadState* __tstate = wxPyBeginAllowThreads();
4462 wxObject_Destroy(arg1);
4463 wxPyEndAllowThreads(__tstate);
4464 if (PyErr_Occurred()) SWIG_fail;
4465 }
4466 resultobj = SWIG_Py_Void();
4467 return resultobj;
4468 fail:
4469 return NULL;
4470 }
4471
4472
4473 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4474 PyObject *obj;
4475 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4476 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4477 return SWIG_Py_Void();
4478 }
4479
4480 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4481 PyObject *resultobj = 0;
4482 wxSize *arg1 = (wxSize *) 0 ;
4483 int arg2 ;
4484 void *argp1 = 0 ;
4485 int res1 = 0 ;
4486 int val2 ;
4487 int ecode2 = 0 ;
4488 PyObject *swig_obj[2] ;
4489
4490 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4492 if (!SWIG_IsOK(res1)) {
4493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4494 }
4495 arg1 = reinterpret_cast< wxSize * >(argp1);
4496 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4497 if (!SWIG_IsOK(ecode2)) {
4498 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4499 }
4500 arg2 = static_cast< int >(val2);
4501 if (arg1) (arg1)->x = arg2;
4502
4503 resultobj = SWIG_Py_Void();
4504 return resultobj;
4505 fail:
4506 return NULL;
4507 }
4508
4509
4510 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4511 PyObject *resultobj = 0;
4512 wxSize *arg1 = (wxSize *) 0 ;
4513 int result;
4514 void *argp1 = 0 ;
4515 int res1 = 0 ;
4516 PyObject *swig_obj[1] ;
4517
4518 if (!args) SWIG_fail;
4519 swig_obj[0] = args;
4520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4521 if (!SWIG_IsOK(res1)) {
4522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4523 }
4524 arg1 = reinterpret_cast< wxSize * >(argp1);
4525 result = (int) ((arg1)->x);
4526 resultobj = SWIG_From_int(static_cast< int >(result));
4527 return resultobj;
4528 fail:
4529 return NULL;
4530 }
4531
4532
4533 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4534 PyObject *resultobj = 0;
4535 wxSize *arg1 = (wxSize *) 0 ;
4536 int arg2 ;
4537 void *argp1 = 0 ;
4538 int res1 = 0 ;
4539 int val2 ;
4540 int ecode2 = 0 ;
4541 PyObject *swig_obj[2] ;
4542
4543 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4544 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4545 if (!SWIG_IsOK(res1)) {
4546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4547 }
4548 arg1 = reinterpret_cast< wxSize * >(argp1);
4549 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4550 if (!SWIG_IsOK(ecode2)) {
4551 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4552 }
4553 arg2 = static_cast< int >(val2);
4554 if (arg1) (arg1)->y = arg2;
4555
4556 resultobj = SWIG_Py_Void();
4557 return resultobj;
4558 fail:
4559 return NULL;
4560 }
4561
4562
4563 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4564 PyObject *resultobj = 0;
4565 wxSize *arg1 = (wxSize *) 0 ;
4566 int result;
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_wxSize, 0 | 0 );
4574 if (!SWIG_IsOK(res1)) {
4575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4576 }
4577 arg1 = reinterpret_cast< wxSize * >(argp1);
4578 result = (int) ((arg1)->y);
4579 resultobj = SWIG_From_int(static_cast< int >(result));
4580 return resultobj;
4581 fail:
4582 return NULL;
4583 }
4584
4585
4586 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4587 PyObject *resultobj = 0;
4588 int arg1 = (int) 0 ;
4589 int arg2 = (int) 0 ;
4590 wxSize *result = 0 ;
4591 int val1 ;
4592 int ecode1 = 0 ;
4593 int val2 ;
4594 int ecode2 = 0 ;
4595 PyObject * obj0 = 0 ;
4596 PyObject * obj1 = 0 ;
4597 char * kwnames[] = {
4598 (char *) "w",(char *) "h", NULL
4599 };
4600
4601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4602 if (obj0) {
4603 ecode1 = SWIG_AsVal_int(obj0, &val1);
4604 if (!SWIG_IsOK(ecode1)) {
4605 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4606 }
4607 arg1 = static_cast< int >(val1);
4608 }
4609 if (obj1) {
4610 ecode2 = SWIG_AsVal_int(obj1, &val2);
4611 if (!SWIG_IsOK(ecode2)) {
4612 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4613 }
4614 arg2 = static_cast< int >(val2);
4615 }
4616 {
4617 PyThreadState* __tstate = wxPyBeginAllowThreads();
4618 result = (wxSize *)new wxSize(arg1,arg2);
4619 wxPyEndAllowThreads(__tstate);
4620 if (PyErr_Occurred()) SWIG_fail;
4621 }
4622 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4623 return resultobj;
4624 fail:
4625 return NULL;
4626 }
4627
4628
4629 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4630 PyObject *resultobj = 0;
4631 wxSize *arg1 = (wxSize *) 0 ;
4632 void *argp1 = 0 ;
4633 int res1 = 0 ;
4634 PyObject *swig_obj[1] ;
4635
4636 if (!args) SWIG_fail;
4637 swig_obj[0] = args;
4638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4639 if (!SWIG_IsOK(res1)) {
4640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4641 }
4642 arg1 = reinterpret_cast< wxSize * >(argp1);
4643 {
4644 PyThreadState* __tstate = wxPyBeginAllowThreads();
4645 delete arg1;
4646
4647 wxPyEndAllowThreads(__tstate);
4648 if (PyErr_Occurred()) SWIG_fail;
4649 }
4650 resultobj = SWIG_Py_Void();
4651 return resultobj;
4652 fail:
4653 return NULL;
4654 }
4655
4656
4657 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4658 PyObject *resultobj = 0;
4659 wxSize *arg1 = (wxSize *) 0 ;
4660 PyObject *arg2 = (PyObject *) 0 ;
4661 bool result;
4662 void *argp1 = 0 ;
4663 int res1 = 0 ;
4664 PyObject * obj0 = 0 ;
4665 PyObject * obj1 = 0 ;
4666 char * kwnames[] = {
4667 (char *) "self",(char *) "other", NULL
4668 };
4669
4670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4672 if (!SWIG_IsOK(res1)) {
4673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4674 }
4675 arg1 = reinterpret_cast< wxSize * >(argp1);
4676 arg2 = obj1;
4677 {
4678 result = (bool)wxSize___eq__(arg1,arg2);
4679 if (PyErr_Occurred()) SWIG_fail;
4680 }
4681 {
4682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4683 }
4684 return resultobj;
4685 fail:
4686 return NULL;
4687 }
4688
4689
4690 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4691 PyObject *resultobj = 0;
4692 wxSize *arg1 = (wxSize *) 0 ;
4693 PyObject *arg2 = (PyObject *) 0 ;
4694 bool result;
4695 void *argp1 = 0 ;
4696 int res1 = 0 ;
4697 PyObject * obj0 = 0 ;
4698 PyObject * obj1 = 0 ;
4699 char * kwnames[] = {
4700 (char *) "self",(char *) "other", NULL
4701 };
4702
4703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4705 if (!SWIG_IsOK(res1)) {
4706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4707 }
4708 arg1 = reinterpret_cast< wxSize * >(argp1);
4709 arg2 = obj1;
4710 {
4711 result = (bool)wxSize___ne__(arg1,arg2);
4712 if (PyErr_Occurred()) SWIG_fail;
4713 }
4714 {
4715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4716 }
4717 return resultobj;
4718 fail:
4719 return NULL;
4720 }
4721
4722
4723 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4724 PyObject *resultobj = 0;
4725 wxSize *arg1 = (wxSize *) 0 ;
4726 wxSize *arg2 = 0 ;
4727 wxSize result;
4728 void *argp1 = 0 ;
4729 int res1 = 0 ;
4730 wxSize temp2 ;
4731 PyObject * obj0 = 0 ;
4732 PyObject * obj1 = 0 ;
4733 char * kwnames[] = {
4734 (char *) "self",(char *) "sz", NULL
4735 };
4736
4737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4739 if (!SWIG_IsOK(res1)) {
4740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4741 }
4742 arg1 = reinterpret_cast< wxSize * >(argp1);
4743 {
4744 arg2 = &temp2;
4745 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4746 }
4747 {
4748 PyThreadState* __tstate = wxPyBeginAllowThreads();
4749 result = (arg1)->operator +((wxSize const &)*arg2);
4750 wxPyEndAllowThreads(__tstate);
4751 if (PyErr_Occurred()) SWIG_fail;
4752 }
4753 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4754 return resultobj;
4755 fail:
4756 return NULL;
4757 }
4758
4759
4760 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4761 PyObject *resultobj = 0;
4762 wxSize *arg1 = (wxSize *) 0 ;
4763 wxSize *arg2 = 0 ;
4764 wxSize result;
4765 void *argp1 = 0 ;
4766 int res1 = 0 ;
4767 wxSize temp2 ;
4768 PyObject * obj0 = 0 ;
4769 PyObject * obj1 = 0 ;
4770 char * kwnames[] = {
4771 (char *) "self",(char *) "sz", NULL
4772 };
4773
4774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4776 if (!SWIG_IsOK(res1)) {
4777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4778 }
4779 arg1 = reinterpret_cast< wxSize * >(argp1);
4780 {
4781 arg2 = &temp2;
4782 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4783 }
4784 {
4785 PyThreadState* __tstate = wxPyBeginAllowThreads();
4786 result = (arg1)->operator -((wxSize const &)*arg2);
4787 wxPyEndAllowThreads(__tstate);
4788 if (PyErr_Occurred()) SWIG_fail;
4789 }
4790 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4791 return resultobj;
4792 fail:
4793 return NULL;
4794 }
4795
4796
4797 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4798 PyObject *resultobj = 0;
4799 wxSize *arg1 = (wxSize *) 0 ;
4800 wxSize *arg2 = 0 ;
4801 void *argp1 = 0 ;
4802 int res1 = 0 ;
4803 wxSize temp2 ;
4804 PyObject * obj0 = 0 ;
4805 PyObject * obj1 = 0 ;
4806 char * kwnames[] = {
4807 (char *) "self",(char *) "sz", NULL
4808 };
4809
4810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4812 if (!SWIG_IsOK(res1)) {
4813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4814 }
4815 arg1 = reinterpret_cast< wxSize * >(argp1);
4816 {
4817 arg2 = &temp2;
4818 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4819 }
4820 {
4821 PyThreadState* __tstate = wxPyBeginAllowThreads();
4822 (arg1)->IncTo((wxSize const &)*arg2);
4823 wxPyEndAllowThreads(__tstate);
4824 if (PyErr_Occurred()) SWIG_fail;
4825 }
4826 resultobj = SWIG_Py_Void();
4827 return resultobj;
4828 fail:
4829 return NULL;
4830 }
4831
4832
4833 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4834 PyObject *resultobj = 0;
4835 wxSize *arg1 = (wxSize *) 0 ;
4836 wxSize *arg2 = 0 ;
4837 void *argp1 = 0 ;
4838 int res1 = 0 ;
4839 wxSize temp2 ;
4840 PyObject * obj0 = 0 ;
4841 PyObject * obj1 = 0 ;
4842 char * kwnames[] = {
4843 (char *) "self",(char *) "sz", NULL
4844 };
4845
4846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4848 if (!SWIG_IsOK(res1)) {
4849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4850 }
4851 arg1 = reinterpret_cast< wxSize * >(argp1);
4852 {
4853 arg2 = &temp2;
4854 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4855 }
4856 {
4857 PyThreadState* __tstate = wxPyBeginAllowThreads();
4858 (arg1)->DecTo((wxSize const &)*arg2);
4859 wxPyEndAllowThreads(__tstate);
4860 if (PyErr_Occurred()) SWIG_fail;
4861 }
4862 resultobj = SWIG_Py_Void();
4863 return resultobj;
4864 fail:
4865 return NULL;
4866 }
4867
4868
4869 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4870 PyObject *resultobj = 0;
4871 wxSize *arg1 = (wxSize *) 0 ;
4872 float arg2 ;
4873 float arg3 ;
4874 void *argp1 = 0 ;
4875 int res1 = 0 ;
4876 float val2 ;
4877 int ecode2 = 0 ;
4878 float val3 ;
4879 int ecode3 = 0 ;
4880 PyObject * obj0 = 0 ;
4881 PyObject * obj1 = 0 ;
4882 PyObject * obj2 = 0 ;
4883 char * kwnames[] = {
4884 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
4885 };
4886
4887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4889 if (!SWIG_IsOK(res1)) {
4890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
4891 }
4892 arg1 = reinterpret_cast< wxSize * >(argp1);
4893 ecode2 = SWIG_AsVal_float(obj1, &val2);
4894 if (!SWIG_IsOK(ecode2)) {
4895 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
4896 }
4897 arg2 = static_cast< float >(val2);
4898 ecode3 = SWIG_AsVal_float(obj2, &val3);
4899 if (!SWIG_IsOK(ecode3)) {
4900 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
4901 }
4902 arg3 = static_cast< float >(val3);
4903 {
4904 PyThreadState* __tstate = wxPyBeginAllowThreads();
4905 (arg1)->Scale(arg2,arg3);
4906 wxPyEndAllowThreads(__tstate);
4907 if (PyErr_Occurred()) SWIG_fail;
4908 }
4909 resultobj = SWIG_Py_Void();
4910 return resultobj;
4911 fail:
4912 return NULL;
4913 }
4914
4915
4916 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4917 PyObject *resultobj = 0;
4918 wxSize *arg1 = (wxSize *) 0 ;
4919 int arg2 ;
4920 int arg3 ;
4921 void *argp1 = 0 ;
4922 int res1 = 0 ;
4923 int val2 ;
4924 int ecode2 = 0 ;
4925 int val3 ;
4926 int ecode3 = 0 ;
4927 PyObject * obj0 = 0 ;
4928 PyObject * obj1 = 0 ;
4929 PyObject * obj2 = 0 ;
4930 char * kwnames[] = {
4931 (char *) "self",(char *) "w",(char *) "h", NULL
4932 };
4933
4934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4936 if (!SWIG_IsOK(res1)) {
4937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
4938 }
4939 arg1 = reinterpret_cast< wxSize * >(argp1);
4940 ecode2 = SWIG_AsVal_int(obj1, &val2);
4941 if (!SWIG_IsOK(ecode2)) {
4942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
4943 }
4944 arg2 = static_cast< int >(val2);
4945 ecode3 = SWIG_AsVal_int(obj2, &val3);
4946 if (!SWIG_IsOK(ecode3)) {
4947 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
4948 }
4949 arg3 = static_cast< int >(val3);
4950 {
4951 PyThreadState* __tstate = wxPyBeginAllowThreads();
4952 (arg1)->Set(arg2,arg3);
4953 wxPyEndAllowThreads(__tstate);
4954 if (PyErr_Occurred()) SWIG_fail;
4955 }
4956 resultobj = SWIG_Py_Void();
4957 return resultobj;
4958 fail:
4959 return NULL;
4960 }
4961
4962
4963 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4964 PyObject *resultobj = 0;
4965 wxSize *arg1 = (wxSize *) 0 ;
4966 int arg2 ;
4967 void *argp1 = 0 ;
4968 int res1 = 0 ;
4969 int val2 ;
4970 int ecode2 = 0 ;
4971 PyObject * obj0 = 0 ;
4972 PyObject * obj1 = 0 ;
4973 char * kwnames[] = {
4974 (char *) "self",(char *) "w", NULL
4975 };
4976
4977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4979 if (!SWIG_IsOK(res1)) {
4980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
4981 }
4982 arg1 = reinterpret_cast< wxSize * >(argp1);
4983 ecode2 = SWIG_AsVal_int(obj1, &val2);
4984 if (!SWIG_IsOK(ecode2)) {
4985 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
4986 }
4987 arg2 = static_cast< int >(val2);
4988 {
4989 PyThreadState* __tstate = wxPyBeginAllowThreads();
4990 (arg1)->SetWidth(arg2);
4991 wxPyEndAllowThreads(__tstate);
4992 if (PyErr_Occurred()) SWIG_fail;
4993 }
4994 resultobj = SWIG_Py_Void();
4995 return resultobj;
4996 fail:
4997 return NULL;
4998 }
4999
5000
5001 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5002 PyObject *resultobj = 0;
5003 wxSize *arg1 = (wxSize *) 0 ;
5004 int arg2 ;
5005 void *argp1 = 0 ;
5006 int res1 = 0 ;
5007 int val2 ;
5008 int ecode2 = 0 ;
5009 PyObject * obj0 = 0 ;
5010 PyObject * obj1 = 0 ;
5011 char * kwnames[] = {
5012 (char *) "self",(char *) "h", NULL
5013 };
5014
5015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
5016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5017 if (!SWIG_IsOK(res1)) {
5018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
5019 }
5020 arg1 = reinterpret_cast< wxSize * >(argp1);
5021 ecode2 = SWIG_AsVal_int(obj1, &val2);
5022 if (!SWIG_IsOK(ecode2)) {
5023 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5024 }
5025 arg2 = static_cast< int >(val2);
5026 {
5027 PyThreadState* __tstate = wxPyBeginAllowThreads();
5028 (arg1)->SetHeight(arg2);
5029 wxPyEndAllowThreads(__tstate);
5030 if (PyErr_Occurred()) SWIG_fail;
5031 }
5032 resultobj = SWIG_Py_Void();
5033 return resultobj;
5034 fail:
5035 return NULL;
5036 }
5037
5038
5039 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5040 PyObject *resultobj = 0;
5041 wxSize *arg1 = (wxSize *) 0 ;
5042 int result;
5043 void *argp1 = 0 ;
5044 int res1 = 0 ;
5045 PyObject *swig_obj[1] ;
5046
5047 if (!args) SWIG_fail;
5048 swig_obj[0] = args;
5049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5050 if (!SWIG_IsOK(res1)) {
5051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5052 }
5053 arg1 = reinterpret_cast< wxSize * >(argp1);
5054 {
5055 PyThreadState* __tstate = wxPyBeginAllowThreads();
5056 result = (int)((wxSize const *)arg1)->GetWidth();
5057 wxPyEndAllowThreads(__tstate);
5058 if (PyErr_Occurred()) SWIG_fail;
5059 }
5060 resultobj = SWIG_From_int(static_cast< int >(result));
5061 return resultobj;
5062 fail:
5063 return NULL;
5064 }
5065
5066
5067 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5068 PyObject *resultobj = 0;
5069 wxSize *arg1 = (wxSize *) 0 ;
5070 int result;
5071 void *argp1 = 0 ;
5072 int res1 = 0 ;
5073 PyObject *swig_obj[1] ;
5074
5075 if (!args) SWIG_fail;
5076 swig_obj[0] = args;
5077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5078 if (!SWIG_IsOK(res1)) {
5079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5080 }
5081 arg1 = reinterpret_cast< wxSize * >(argp1);
5082 {
5083 PyThreadState* __tstate = wxPyBeginAllowThreads();
5084 result = (int)((wxSize const *)arg1)->GetHeight();
5085 wxPyEndAllowThreads(__tstate);
5086 if (PyErr_Occurred()) SWIG_fail;
5087 }
5088 resultobj = SWIG_From_int(static_cast< int >(result));
5089 return resultobj;
5090 fail:
5091 return NULL;
5092 }
5093
5094
5095 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5096 PyObject *resultobj = 0;
5097 wxSize *arg1 = (wxSize *) 0 ;
5098 bool result;
5099 void *argp1 = 0 ;
5100 int res1 = 0 ;
5101 PyObject *swig_obj[1] ;
5102
5103 if (!args) SWIG_fail;
5104 swig_obj[0] = args;
5105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5106 if (!SWIG_IsOK(res1)) {
5107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5108 }
5109 arg1 = reinterpret_cast< wxSize * >(argp1);
5110 {
5111 PyThreadState* __tstate = wxPyBeginAllowThreads();
5112 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5113 wxPyEndAllowThreads(__tstate);
5114 if (PyErr_Occurred()) SWIG_fail;
5115 }
5116 {
5117 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5118 }
5119 return resultobj;
5120 fail:
5121 return NULL;
5122 }
5123
5124
5125 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5126 PyObject *resultobj = 0;
5127 wxSize *arg1 = (wxSize *) 0 ;
5128 wxSize *arg2 = 0 ;
5129 void *argp1 = 0 ;
5130 int res1 = 0 ;
5131 wxSize temp2 ;
5132 PyObject * obj0 = 0 ;
5133 PyObject * obj1 = 0 ;
5134 char * kwnames[] = {
5135 (char *) "self",(char *) "size", NULL
5136 };
5137
5138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5140 if (!SWIG_IsOK(res1)) {
5141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5142 }
5143 arg1 = reinterpret_cast< wxSize * >(argp1);
5144 {
5145 arg2 = &temp2;
5146 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5147 }
5148 {
5149 PyThreadState* __tstate = wxPyBeginAllowThreads();
5150 (arg1)->SetDefaults((wxSize const &)*arg2);
5151 wxPyEndAllowThreads(__tstate);
5152 if (PyErr_Occurred()) SWIG_fail;
5153 }
5154 resultobj = SWIG_Py_Void();
5155 return resultobj;
5156 fail:
5157 return NULL;
5158 }
5159
5160
5161 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5162 PyObject *resultobj = 0;
5163 wxSize *arg1 = (wxSize *) 0 ;
5164 PyObject *result = 0 ;
5165 void *argp1 = 0 ;
5166 int res1 = 0 ;
5167 PyObject *swig_obj[1] ;
5168
5169 if (!args) SWIG_fail;
5170 swig_obj[0] = args;
5171 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5172 if (!SWIG_IsOK(res1)) {
5173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5174 }
5175 arg1 = reinterpret_cast< wxSize * >(argp1);
5176 {
5177 PyThreadState* __tstate = wxPyBeginAllowThreads();
5178 result = (PyObject *)wxSize_Get(arg1);
5179 wxPyEndAllowThreads(__tstate);
5180 if (PyErr_Occurred()) SWIG_fail;
5181 }
5182 resultobj = result;
5183 return resultobj;
5184 fail:
5185 return NULL;
5186 }
5187
5188
5189 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5190 PyObject *obj;
5191 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5192 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5193 return SWIG_Py_Void();
5194 }
5195
5196 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5197 return SWIG_Python_InitShadowInstance(args);
5198 }
5199
5200 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5201 PyObject *resultobj = 0;
5202 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5203 double arg2 ;
5204 void *argp1 = 0 ;
5205 int res1 = 0 ;
5206 double val2 ;
5207 int ecode2 = 0 ;
5208 PyObject *swig_obj[2] ;
5209
5210 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5212 if (!SWIG_IsOK(res1)) {
5213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5214 }
5215 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5216 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5217 if (!SWIG_IsOK(ecode2)) {
5218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5219 }
5220 arg2 = static_cast< double >(val2);
5221 if (arg1) (arg1)->x = arg2;
5222
5223 resultobj = SWIG_Py_Void();
5224 return resultobj;
5225 fail:
5226 return NULL;
5227 }
5228
5229
5230 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5231 PyObject *resultobj = 0;
5232 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5233 double result;
5234 void *argp1 = 0 ;
5235 int res1 = 0 ;
5236 PyObject *swig_obj[1] ;
5237
5238 if (!args) SWIG_fail;
5239 swig_obj[0] = args;
5240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5241 if (!SWIG_IsOK(res1)) {
5242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5243 }
5244 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5245 result = (double) ((arg1)->x);
5246 resultobj = SWIG_From_double(static_cast< double >(result));
5247 return resultobj;
5248 fail:
5249 return NULL;
5250 }
5251
5252
5253 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5254 PyObject *resultobj = 0;
5255 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5256 double arg2 ;
5257 void *argp1 = 0 ;
5258 int res1 = 0 ;
5259 double val2 ;
5260 int ecode2 = 0 ;
5261 PyObject *swig_obj[2] ;
5262
5263 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5265 if (!SWIG_IsOK(res1)) {
5266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5267 }
5268 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5269 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5270 if (!SWIG_IsOK(ecode2)) {
5271 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5272 }
5273 arg2 = static_cast< double >(val2);
5274 if (arg1) (arg1)->y = arg2;
5275
5276 resultobj = SWIG_Py_Void();
5277 return resultobj;
5278 fail:
5279 return NULL;
5280 }
5281
5282
5283 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5284 PyObject *resultobj = 0;
5285 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5286 double result;
5287 void *argp1 = 0 ;
5288 int res1 = 0 ;
5289 PyObject *swig_obj[1] ;
5290
5291 if (!args) SWIG_fail;
5292 swig_obj[0] = args;
5293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5294 if (!SWIG_IsOK(res1)) {
5295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5296 }
5297 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5298 result = (double) ((arg1)->y);
5299 resultobj = SWIG_From_double(static_cast< double >(result));
5300 return resultobj;
5301 fail:
5302 return NULL;
5303 }
5304
5305
5306 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5307 PyObject *resultobj = 0;
5308 double arg1 = (double) 0.0 ;
5309 double arg2 = (double) 0.0 ;
5310 wxRealPoint *result = 0 ;
5311 double val1 ;
5312 int ecode1 = 0 ;
5313 double val2 ;
5314 int ecode2 = 0 ;
5315 PyObject * obj0 = 0 ;
5316 PyObject * obj1 = 0 ;
5317 char * kwnames[] = {
5318 (char *) "x",(char *) "y", NULL
5319 };
5320
5321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5322 if (obj0) {
5323 ecode1 = SWIG_AsVal_double(obj0, &val1);
5324 if (!SWIG_IsOK(ecode1)) {
5325 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5326 }
5327 arg1 = static_cast< double >(val1);
5328 }
5329 if (obj1) {
5330 ecode2 = SWIG_AsVal_double(obj1, &val2);
5331 if (!SWIG_IsOK(ecode2)) {
5332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5333 }
5334 arg2 = static_cast< double >(val2);
5335 }
5336 {
5337 PyThreadState* __tstate = wxPyBeginAllowThreads();
5338 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5339 wxPyEndAllowThreads(__tstate);
5340 if (PyErr_Occurred()) SWIG_fail;
5341 }
5342 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5343 return resultobj;
5344 fail:
5345 return NULL;
5346 }
5347
5348
5349 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5350 PyObject *resultobj = 0;
5351 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5352 void *argp1 = 0 ;
5353 int res1 = 0 ;
5354 PyObject *swig_obj[1] ;
5355
5356 if (!args) SWIG_fail;
5357 swig_obj[0] = args;
5358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5359 if (!SWIG_IsOK(res1)) {
5360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5361 }
5362 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5363 {
5364 PyThreadState* __tstate = wxPyBeginAllowThreads();
5365 delete arg1;
5366
5367 wxPyEndAllowThreads(__tstate);
5368 if (PyErr_Occurred()) SWIG_fail;
5369 }
5370 resultobj = SWIG_Py_Void();
5371 return resultobj;
5372 fail:
5373 return NULL;
5374 }
5375
5376
5377 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5378 PyObject *resultobj = 0;
5379 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5380 PyObject *arg2 = (PyObject *) 0 ;
5381 bool result;
5382 void *argp1 = 0 ;
5383 int res1 = 0 ;
5384 PyObject * obj0 = 0 ;
5385 PyObject * obj1 = 0 ;
5386 char * kwnames[] = {
5387 (char *) "self",(char *) "other", NULL
5388 };
5389
5390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5392 if (!SWIG_IsOK(res1)) {
5393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5394 }
5395 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5396 arg2 = obj1;
5397 {
5398 result = (bool)wxRealPoint___eq__(arg1,arg2);
5399 if (PyErr_Occurred()) SWIG_fail;
5400 }
5401 {
5402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5403 }
5404 return resultobj;
5405 fail:
5406 return NULL;
5407 }
5408
5409
5410 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5411 PyObject *resultobj = 0;
5412 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5413 PyObject *arg2 = (PyObject *) 0 ;
5414 bool result;
5415 void *argp1 = 0 ;
5416 int res1 = 0 ;
5417 PyObject * obj0 = 0 ;
5418 PyObject * obj1 = 0 ;
5419 char * kwnames[] = {
5420 (char *) "self",(char *) "other", NULL
5421 };
5422
5423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5425 if (!SWIG_IsOK(res1)) {
5426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5427 }
5428 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5429 arg2 = obj1;
5430 {
5431 result = (bool)wxRealPoint___ne__(arg1,arg2);
5432 if (PyErr_Occurred()) SWIG_fail;
5433 }
5434 {
5435 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5436 }
5437 return resultobj;
5438 fail:
5439 return NULL;
5440 }
5441
5442
5443 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5444 PyObject *resultobj = 0;
5445 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5446 wxRealPoint *arg2 = 0 ;
5447 wxRealPoint result;
5448 void *argp1 = 0 ;
5449 int res1 = 0 ;
5450 wxRealPoint temp2 ;
5451 PyObject * obj0 = 0 ;
5452 PyObject * obj1 = 0 ;
5453 char * kwnames[] = {
5454 (char *) "self",(char *) "pt", NULL
5455 };
5456
5457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5459 if (!SWIG_IsOK(res1)) {
5460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5461 }
5462 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5463 {
5464 arg2 = &temp2;
5465 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5466 }
5467 {
5468 PyThreadState* __tstate = wxPyBeginAllowThreads();
5469 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5470 wxPyEndAllowThreads(__tstate);
5471 if (PyErr_Occurred()) SWIG_fail;
5472 }
5473 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5474 return resultobj;
5475 fail:
5476 return NULL;
5477 }
5478
5479
5480 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5481 PyObject *resultobj = 0;
5482 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5483 wxRealPoint *arg2 = 0 ;
5484 wxRealPoint result;
5485 void *argp1 = 0 ;
5486 int res1 = 0 ;
5487 wxRealPoint temp2 ;
5488 PyObject * obj0 = 0 ;
5489 PyObject * obj1 = 0 ;
5490 char * kwnames[] = {
5491 (char *) "self",(char *) "pt", NULL
5492 };
5493
5494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5496 if (!SWIG_IsOK(res1)) {
5497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5498 }
5499 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5500 {
5501 arg2 = &temp2;
5502 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5503 }
5504 {
5505 PyThreadState* __tstate = wxPyBeginAllowThreads();
5506 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5507 wxPyEndAllowThreads(__tstate);
5508 if (PyErr_Occurred()) SWIG_fail;
5509 }
5510 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5511 return resultobj;
5512 fail:
5513 return NULL;
5514 }
5515
5516
5517 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5518 PyObject *resultobj = 0;
5519 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5520 double arg2 ;
5521 double arg3 ;
5522 void *argp1 = 0 ;
5523 int res1 = 0 ;
5524 double val2 ;
5525 int ecode2 = 0 ;
5526 double val3 ;
5527 int ecode3 = 0 ;
5528 PyObject * obj0 = 0 ;
5529 PyObject * obj1 = 0 ;
5530 PyObject * obj2 = 0 ;
5531 char * kwnames[] = {
5532 (char *) "self",(char *) "x",(char *) "y", NULL
5533 };
5534
5535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5537 if (!SWIG_IsOK(res1)) {
5538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5539 }
5540 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5541 ecode2 = SWIG_AsVal_double(obj1, &val2);
5542 if (!SWIG_IsOK(ecode2)) {
5543 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5544 }
5545 arg2 = static_cast< double >(val2);
5546 ecode3 = SWIG_AsVal_double(obj2, &val3);
5547 if (!SWIG_IsOK(ecode3)) {
5548 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5549 }
5550 arg3 = static_cast< double >(val3);
5551 {
5552 PyThreadState* __tstate = wxPyBeginAllowThreads();
5553 wxRealPoint_Set(arg1,arg2,arg3);
5554 wxPyEndAllowThreads(__tstate);
5555 if (PyErr_Occurred()) SWIG_fail;
5556 }
5557 resultobj = SWIG_Py_Void();
5558 return resultobj;
5559 fail:
5560 return NULL;
5561 }
5562
5563
5564 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5565 PyObject *resultobj = 0;
5566 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5567 PyObject *result = 0 ;
5568 void *argp1 = 0 ;
5569 int res1 = 0 ;
5570 PyObject *swig_obj[1] ;
5571
5572 if (!args) SWIG_fail;
5573 swig_obj[0] = args;
5574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5575 if (!SWIG_IsOK(res1)) {
5576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5577 }
5578 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5579 {
5580 PyThreadState* __tstate = wxPyBeginAllowThreads();
5581 result = (PyObject *)wxRealPoint_Get(arg1);
5582 wxPyEndAllowThreads(__tstate);
5583 if (PyErr_Occurred()) SWIG_fail;
5584 }
5585 resultobj = result;
5586 return resultobj;
5587 fail:
5588 return NULL;
5589 }
5590
5591
5592 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5593 PyObject *obj;
5594 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5595 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5596 return SWIG_Py_Void();
5597 }
5598
5599 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5600 return SWIG_Python_InitShadowInstance(args);
5601 }
5602
5603 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5604 PyObject *resultobj = 0;
5605 wxPoint *arg1 = (wxPoint *) 0 ;
5606 int arg2 ;
5607 void *argp1 = 0 ;
5608 int res1 = 0 ;
5609 int val2 ;
5610 int ecode2 = 0 ;
5611 PyObject *swig_obj[2] ;
5612
5613 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5615 if (!SWIG_IsOK(res1)) {
5616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5617 }
5618 arg1 = reinterpret_cast< wxPoint * >(argp1);
5619 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5620 if (!SWIG_IsOK(ecode2)) {
5621 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5622 }
5623 arg2 = static_cast< int >(val2);
5624 if (arg1) (arg1)->x = arg2;
5625
5626 resultobj = SWIG_Py_Void();
5627 return resultobj;
5628 fail:
5629 return NULL;
5630 }
5631
5632
5633 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5634 PyObject *resultobj = 0;
5635 wxPoint *arg1 = (wxPoint *) 0 ;
5636 int result;
5637 void *argp1 = 0 ;
5638 int res1 = 0 ;
5639 PyObject *swig_obj[1] ;
5640
5641 if (!args) SWIG_fail;
5642 swig_obj[0] = args;
5643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5644 if (!SWIG_IsOK(res1)) {
5645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5646 }
5647 arg1 = reinterpret_cast< wxPoint * >(argp1);
5648 result = (int) ((arg1)->x);
5649 resultobj = SWIG_From_int(static_cast< int >(result));
5650 return resultobj;
5651 fail:
5652 return NULL;
5653 }
5654
5655
5656 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5657 PyObject *resultobj = 0;
5658 wxPoint *arg1 = (wxPoint *) 0 ;
5659 int arg2 ;
5660 void *argp1 = 0 ;
5661 int res1 = 0 ;
5662 int val2 ;
5663 int ecode2 = 0 ;
5664 PyObject *swig_obj[2] ;
5665
5666 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5668 if (!SWIG_IsOK(res1)) {
5669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5670 }
5671 arg1 = reinterpret_cast< wxPoint * >(argp1);
5672 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5673 if (!SWIG_IsOK(ecode2)) {
5674 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5675 }
5676 arg2 = static_cast< int >(val2);
5677 if (arg1) (arg1)->y = arg2;
5678
5679 resultobj = SWIG_Py_Void();
5680 return resultobj;
5681 fail:
5682 return NULL;
5683 }
5684
5685
5686 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5687 PyObject *resultobj = 0;
5688 wxPoint *arg1 = (wxPoint *) 0 ;
5689 int result;
5690 void *argp1 = 0 ;
5691 int res1 = 0 ;
5692 PyObject *swig_obj[1] ;
5693
5694 if (!args) SWIG_fail;
5695 swig_obj[0] = args;
5696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5697 if (!SWIG_IsOK(res1)) {
5698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5699 }
5700 arg1 = reinterpret_cast< wxPoint * >(argp1);
5701 result = (int) ((arg1)->y);
5702 resultobj = SWIG_From_int(static_cast< int >(result));
5703 return resultobj;
5704 fail:
5705 return NULL;
5706 }
5707
5708
5709 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5710 PyObject *resultobj = 0;
5711 int arg1 = (int) 0 ;
5712 int arg2 = (int) 0 ;
5713 wxPoint *result = 0 ;
5714 int val1 ;
5715 int ecode1 = 0 ;
5716 int val2 ;
5717 int ecode2 = 0 ;
5718 PyObject * obj0 = 0 ;
5719 PyObject * obj1 = 0 ;
5720 char * kwnames[] = {
5721 (char *) "x",(char *) "y", NULL
5722 };
5723
5724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5725 if (obj0) {
5726 ecode1 = SWIG_AsVal_int(obj0, &val1);
5727 if (!SWIG_IsOK(ecode1)) {
5728 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5729 }
5730 arg1 = static_cast< int >(val1);
5731 }
5732 if (obj1) {
5733 ecode2 = SWIG_AsVal_int(obj1, &val2);
5734 if (!SWIG_IsOK(ecode2)) {
5735 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5736 }
5737 arg2 = static_cast< int >(val2);
5738 }
5739 {
5740 PyThreadState* __tstate = wxPyBeginAllowThreads();
5741 result = (wxPoint *)new wxPoint(arg1,arg2);
5742 wxPyEndAllowThreads(__tstate);
5743 if (PyErr_Occurred()) SWIG_fail;
5744 }
5745 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5746 return resultobj;
5747 fail:
5748 return NULL;
5749 }
5750
5751
5752 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5753 PyObject *resultobj = 0;
5754 wxPoint *arg1 = (wxPoint *) 0 ;
5755 void *argp1 = 0 ;
5756 int res1 = 0 ;
5757 PyObject *swig_obj[1] ;
5758
5759 if (!args) SWIG_fail;
5760 swig_obj[0] = args;
5761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5762 if (!SWIG_IsOK(res1)) {
5763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5764 }
5765 arg1 = reinterpret_cast< wxPoint * >(argp1);
5766 {
5767 PyThreadState* __tstate = wxPyBeginAllowThreads();
5768 delete arg1;
5769
5770 wxPyEndAllowThreads(__tstate);
5771 if (PyErr_Occurred()) SWIG_fail;
5772 }
5773 resultobj = SWIG_Py_Void();
5774 return resultobj;
5775 fail:
5776 return NULL;
5777 }
5778
5779
5780 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5781 PyObject *resultobj = 0;
5782 wxPoint *arg1 = (wxPoint *) 0 ;
5783 PyObject *arg2 = (PyObject *) 0 ;
5784 bool result;
5785 void *argp1 = 0 ;
5786 int res1 = 0 ;
5787 PyObject * obj0 = 0 ;
5788 PyObject * obj1 = 0 ;
5789 char * kwnames[] = {
5790 (char *) "self",(char *) "other", NULL
5791 };
5792
5793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5795 if (!SWIG_IsOK(res1)) {
5796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5797 }
5798 arg1 = reinterpret_cast< wxPoint * >(argp1);
5799 arg2 = obj1;
5800 {
5801 result = (bool)wxPoint___eq__(arg1,arg2);
5802 if (PyErr_Occurred()) SWIG_fail;
5803 }
5804 {
5805 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5806 }
5807 return resultobj;
5808 fail:
5809 return NULL;
5810 }
5811
5812
5813 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5814 PyObject *resultobj = 0;
5815 wxPoint *arg1 = (wxPoint *) 0 ;
5816 PyObject *arg2 = (PyObject *) 0 ;
5817 bool result;
5818 void *argp1 = 0 ;
5819 int res1 = 0 ;
5820 PyObject * obj0 = 0 ;
5821 PyObject * obj1 = 0 ;
5822 char * kwnames[] = {
5823 (char *) "self",(char *) "other", NULL
5824 };
5825
5826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5828 if (!SWIG_IsOK(res1)) {
5829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5830 }
5831 arg1 = reinterpret_cast< wxPoint * >(argp1);
5832 arg2 = obj1;
5833 {
5834 result = (bool)wxPoint___ne__(arg1,arg2);
5835 if (PyErr_Occurred()) SWIG_fail;
5836 }
5837 {
5838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5839 }
5840 return resultobj;
5841 fail:
5842 return NULL;
5843 }
5844
5845
5846 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5847 PyObject *resultobj = 0;
5848 wxPoint *arg1 = (wxPoint *) 0 ;
5849 wxPoint *arg2 = 0 ;
5850 wxPoint result;
5851 void *argp1 = 0 ;
5852 int res1 = 0 ;
5853 wxPoint temp2 ;
5854 PyObject * obj0 = 0 ;
5855 PyObject * obj1 = 0 ;
5856 char * kwnames[] = {
5857 (char *) "self",(char *) "pt", NULL
5858 };
5859
5860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5862 if (!SWIG_IsOK(res1)) {
5863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5864 }
5865 arg1 = reinterpret_cast< wxPoint * >(argp1);
5866 {
5867 arg2 = &temp2;
5868 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5869 }
5870 {
5871 PyThreadState* __tstate = wxPyBeginAllowThreads();
5872 result = (arg1)->operator +((wxPoint const &)*arg2);
5873 wxPyEndAllowThreads(__tstate);
5874 if (PyErr_Occurred()) SWIG_fail;
5875 }
5876 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5877 return resultobj;
5878 fail:
5879 return NULL;
5880 }
5881
5882
5883 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5884 PyObject *resultobj = 0;
5885 wxPoint *arg1 = (wxPoint *) 0 ;
5886 wxPoint *arg2 = 0 ;
5887 wxPoint result;
5888 void *argp1 = 0 ;
5889 int res1 = 0 ;
5890 wxPoint temp2 ;
5891 PyObject * obj0 = 0 ;
5892 PyObject * obj1 = 0 ;
5893 char * kwnames[] = {
5894 (char *) "self",(char *) "pt", NULL
5895 };
5896
5897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5899 if (!SWIG_IsOK(res1)) {
5900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5901 }
5902 arg1 = reinterpret_cast< wxPoint * >(argp1);
5903 {
5904 arg2 = &temp2;
5905 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5906 }
5907 {
5908 PyThreadState* __tstate = wxPyBeginAllowThreads();
5909 result = (arg1)->operator -((wxPoint const &)*arg2);
5910 wxPyEndAllowThreads(__tstate);
5911 if (PyErr_Occurred()) SWIG_fail;
5912 }
5913 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5914 return resultobj;
5915 fail:
5916 return NULL;
5917 }
5918
5919
5920 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5921 PyObject *resultobj = 0;
5922 wxPoint *arg1 = (wxPoint *) 0 ;
5923 wxPoint *arg2 = 0 ;
5924 wxPoint *result = 0 ;
5925 void *argp1 = 0 ;
5926 int res1 = 0 ;
5927 wxPoint temp2 ;
5928 PyObject * obj0 = 0 ;
5929 PyObject * obj1 = 0 ;
5930 char * kwnames[] = {
5931 (char *) "self",(char *) "pt", NULL
5932 };
5933
5934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
5935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5936 if (!SWIG_IsOK(res1)) {
5937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
5938 }
5939 arg1 = reinterpret_cast< wxPoint * >(argp1);
5940 {
5941 arg2 = &temp2;
5942 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5943 }
5944 {
5945 PyThreadState* __tstate = wxPyBeginAllowThreads();
5946 {
5947 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
5948 result = (wxPoint *) &_result_ref;
5949 }
5950 wxPyEndAllowThreads(__tstate);
5951 if (PyErr_Occurred()) SWIG_fail;
5952 }
5953 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5954 return resultobj;
5955 fail:
5956 return NULL;
5957 }
5958
5959
5960 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5961 PyObject *resultobj = 0;
5962 wxPoint *arg1 = (wxPoint *) 0 ;
5963 wxPoint *arg2 = 0 ;
5964 wxPoint *result = 0 ;
5965 void *argp1 = 0 ;
5966 int res1 = 0 ;
5967 wxPoint temp2 ;
5968 PyObject * obj0 = 0 ;
5969 PyObject * obj1 = 0 ;
5970 char * kwnames[] = {
5971 (char *) "self",(char *) "pt", NULL
5972 };
5973
5974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
5975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5976 if (!SWIG_IsOK(res1)) {
5977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5978 }
5979 arg1 = reinterpret_cast< wxPoint * >(argp1);
5980 {
5981 arg2 = &temp2;
5982 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5983 }
5984 {
5985 PyThreadState* __tstate = wxPyBeginAllowThreads();
5986 {
5987 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
5988 result = (wxPoint *) &_result_ref;
5989 }
5990 wxPyEndAllowThreads(__tstate);
5991 if (PyErr_Occurred()) SWIG_fail;
5992 }
5993 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5994 return resultobj;
5995 fail:
5996 return NULL;
5997 }
5998
5999
6000 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6001 PyObject *resultobj = 0;
6002 wxPoint *arg1 = (wxPoint *) 0 ;
6003 long arg2 ;
6004 long arg3 ;
6005 void *argp1 = 0 ;
6006 int res1 = 0 ;
6007 long val2 ;
6008 int ecode2 = 0 ;
6009 long val3 ;
6010 int ecode3 = 0 ;
6011 PyObject * obj0 = 0 ;
6012 PyObject * obj1 = 0 ;
6013 PyObject * obj2 = 0 ;
6014 char * kwnames[] = {
6015 (char *) "self",(char *) "x",(char *) "y", NULL
6016 };
6017
6018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6020 if (!SWIG_IsOK(res1)) {
6021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6022 }
6023 arg1 = reinterpret_cast< wxPoint * >(argp1);
6024 ecode2 = SWIG_AsVal_long(obj1, &val2);
6025 if (!SWIG_IsOK(ecode2)) {
6026 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6027 }
6028 arg2 = static_cast< long >(val2);
6029 ecode3 = SWIG_AsVal_long(obj2, &val3);
6030 if (!SWIG_IsOK(ecode3)) {
6031 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6032 }
6033 arg3 = static_cast< long >(val3);
6034 {
6035 PyThreadState* __tstate = wxPyBeginAllowThreads();
6036 wxPoint_Set(arg1,arg2,arg3);
6037 wxPyEndAllowThreads(__tstate);
6038 if (PyErr_Occurred()) SWIG_fail;
6039 }
6040 resultobj = SWIG_Py_Void();
6041 return resultobj;
6042 fail:
6043 return NULL;
6044 }
6045
6046
6047 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6048 PyObject *resultobj = 0;
6049 wxPoint *arg1 = (wxPoint *) 0 ;
6050 PyObject *result = 0 ;
6051 void *argp1 = 0 ;
6052 int res1 = 0 ;
6053 PyObject *swig_obj[1] ;
6054
6055 if (!args) SWIG_fail;
6056 swig_obj[0] = args;
6057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6058 if (!SWIG_IsOK(res1)) {
6059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6060 }
6061 arg1 = reinterpret_cast< wxPoint * >(argp1);
6062 {
6063 PyThreadState* __tstate = wxPyBeginAllowThreads();
6064 result = (PyObject *)wxPoint_Get(arg1);
6065 wxPyEndAllowThreads(__tstate);
6066 if (PyErr_Occurred()) SWIG_fail;
6067 }
6068 resultobj = result;
6069 return resultobj;
6070 fail:
6071 return NULL;
6072 }
6073
6074
6075 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6076 PyObject *obj;
6077 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6078 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6079 return SWIG_Py_Void();
6080 }
6081
6082 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6083 return SWIG_Python_InitShadowInstance(args);
6084 }
6085
6086 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6087 PyObject *resultobj = 0;
6088 int arg1 = (int) 0 ;
6089 int arg2 = (int) 0 ;
6090 int arg3 = (int) 0 ;
6091 int arg4 = (int) 0 ;
6092 wxRect *result = 0 ;
6093 int val1 ;
6094 int ecode1 = 0 ;
6095 int val2 ;
6096 int ecode2 = 0 ;
6097 int val3 ;
6098 int ecode3 = 0 ;
6099 int val4 ;
6100 int ecode4 = 0 ;
6101 PyObject * obj0 = 0 ;
6102 PyObject * obj1 = 0 ;
6103 PyObject * obj2 = 0 ;
6104 PyObject * obj3 = 0 ;
6105 char * kwnames[] = {
6106 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6107 };
6108
6109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6110 if (obj0) {
6111 ecode1 = SWIG_AsVal_int(obj0, &val1);
6112 if (!SWIG_IsOK(ecode1)) {
6113 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6114 }
6115 arg1 = static_cast< int >(val1);
6116 }
6117 if (obj1) {
6118 ecode2 = SWIG_AsVal_int(obj1, &val2);
6119 if (!SWIG_IsOK(ecode2)) {
6120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6121 }
6122 arg2 = static_cast< int >(val2);
6123 }
6124 if (obj2) {
6125 ecode3 = SWIG_AsVal_int(obj2, &val3);
6126 if (!SWIG_IsOK(ecode3)) {
6127 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6128 }
6129 arg3 = static_cast< int >(val3);
6130 }
6131 if (obj3) {
6132 ecode4 = SWIG_AsVal_int(obj3, &val4);
6133 if (!SWIG_IsOK(ecode4)) {
6134 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6135 }
6136 arg4 = static_cast< int >(val4);
6137 }
6138 {
6139 PyThreadState* __tstate = wxPyBeginAllowThreads();
6140 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6141 wxPyEndAllowThreads(__tstate);
6142 if (PyErr_Occurred()) SWIG_fail;
6143 }
6144 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6145 return resultobj;
6146 fail:
6147 return NULL;
6148 }
6149
6150
6151 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6152 PyObject *resultobj = 0;
6153 wxPoint *arg1 = 0 ;
6154 wxPoint *arg2 = 0 ;
6155 wxRect *result = 0 ;
6156 wxPoint temp1 ;
6157 wxPoint temp2 ;
6158 PyObject * obj0 = 0 ;
6159 PyObject * obj1 = 0 ;
6160 char * kwnames[] = {
6161 (char *) "topLeft",(char *) "bottomRight", NULL
6162 };
6163
6164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6165 {
6166 arg1 = &temp1;
6167 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6168 }
6169 {
6170 arg2 = &temp2;
6171 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6172 }
6173 {
6174 PyThreadState* __tstate = wxPyBeginAllowThreads();
6175 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6176 wxPyEndAllowThreads(__tstate);
6177 if (PyErr_Occurred()) SWIG_fail;
6178 }
6179 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6180 return resultobj;
6181 fail:
6182 return NULL;
6183 }
6184
6185
6186 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6187 PyObject *resultobj = 0;
6188 wxPoint *arg1 = 0 ;
6189 wxSize *arg2 = 0 ;
6190 wxRect *result = 0 ;
6191 wxPoint temp1 ;
6192 wxSize temp2 ;
6193 PyObject * obj0 = 0 ;
6194 PyObject * obj1 = 0 ;
6195 char * kwnames[] = {
6196 (char *) "pos",(char *) "size", NULL
6197 };
6198
6199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6200 {
6201 arg1 = &temp1;
6202 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6203 }
6204 {
6205 arg2 = &temp2;
6206 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6207 }
6208 {
6209 PyThreadState* __tstate = wxPyBeginAllowThreads();
6210 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6211 wxPyEndAllowThreads(__tstate);
6212 if (PyErr_Occurred()) SWIG_fail;
6213 }
6214 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6215 return resultobj;
6216 fail:
6217 return NULL;
6218 }
6219
6220
6221 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6222 PyObject *resultobj = 0;
6223 wxSize *arg1 = 0 ;
6224 wxRect *result = 0 ;
6225 wxSize temp1 ;
6226 PyObject * obj0 = 0 ;
6227 char * kwnames[] = {
6228 (char *) "size", NULL
6229 };
6230
6231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6232 {
6233 arg1 = &temp1;
6234 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6235 }
6236 {
6237 PyThreadState* __tstate = wxPyBeginAllowThreads();
6238 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6239 wxPyEndAllowThreads(__tstate);
6240 if (PyErr_Occurred()) SWIG_fail;
6241 }
6242 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6243 return resultobj;
6244 fail:
6245 return NULL;
6246 }
6247
6248
6249 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6250 PyObject *resultobj = 0;
6251 wxRect *arg1 = (wxRect *) 0 ;
6252 void *argp1 = 0 ;
6253 int res1 = 0 ;
6254 PyObject *swig_obj[1] ;
6255
6256 if (!args) SWIG_fail;
6257 swig_obj[0] = args;
6258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6259 if (!SWIG_IsOK(res1)) {
6260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6261 }
6262 arg1 = reinterpret_cast< wxRect * >(argp1);
6263 {
6264 PyThreadState* __tstate = wxPyBeginAllowThreads();
6265 delete arg1;
6266
6267 wxPyEndAllowThreads(__tstate);
6268 if (PyErr_Occurred()) SWIG_fail;
6269 }
6270 resultobj = SWIG_Py_Void();
6271 return resultobj;
6272 fail:
6273 return NULL;
6274 }
6275
6276
6277 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6278 PyObject *resultobj = 0;
6279 wxRect *arg1 = (wxRect *) 0 ;
6280 int result;
6281 void *argp1 = 0 ;
6282 int res1 = 0 ;
6283 PyObject *swig_obj[1] ;
6284
6285 if (!args) SWIG_fail;
6286 swig_obj[0] = args;
6287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6288 if (!SWIG_IsOK(res1)) {
6289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6290 }
6291 arg1 = reinterpret_cast< wxRect * >(argp1);
6292 {
6293 PyThreadState* __tstate = wxPyBeginAllowThreads();
6294 result = (int)((wxRect const *)arg1)->GetX();
6295 wxPyEndAllowThreads(__tstate);
6296 if (PyErr_Occurred()) SWIG_fail;
6297 }
6298 resultobj = SWIG_From_int(static_cast< int >(result));
6299 return resultobj;
6300 fail:
6301 return NULL;
6302 }
6303
6304
6305 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6306 PyObject *resultobj = 0;
6307 wxRect *arg1 = (wxRect *) 0 ;
6308 int arg2 ;
6309 void *argp1 = 0 ;
6310 int res1 = 0 ;
6311 int val2 ;
6312 int ecode2 = 0 ;
6313 PyObject * obj0 = 0 ;
6314 PyObject * obj1 = 0 ;
6315 char * kwnames[] = {
6316 (char *) "self",(char *) "x", NULL
6317 };
6318
6319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6321 if (!SWIG_IsOK(res1)) {
6322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6323 }
6324 arg1 = reinterpret_cast< wxRect * >(argp1);
6325 ecode2 = SWIG_AsVal_int(obj1, &val2);
6326 if (!SWIG_IsOK(ecode2)) {
6327 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6328 }
6329 arg2 = static_cast< int >(val2);
6330 {
6331 PyThreadState* __tstate = wxPyBeginAllowThreads();
6332 (arg1)->SetX(arg2);
6333 wxPyEndAllowThreads(__tstate);
6334 if (PyErr_Occurred()) SWIG_fail;
6335 }
6336 resultobj = SWIG_Py_Void();
6337 return resultobj;
6338 fail:
6339 return NULL;
6340 }
6341
6342
6343 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6344 PyObject *resultobj = 0;
6345 wxRect *arg1 = (wxRect *) 0 ;
6346 int result;
6347 void *argp1 = 0 ;
6348 int res1 = 0 ;
6349 PyObject *swig_obj[1] ;
6350
6351 if (!args) SWIG_fail;
6352 swig_obj[0] = args;
6353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6354 if (!SWIG_IsOK(res1)) {
6355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6356 }
6357 arg1 = reinterpret_cast< wxRect * >(argp1);
6358 {
6359 PyThreadState* __tstate = wxPyBeginAllowThreads();
6360 result = (int)(arg1)->GetY();
6361 wxPyEndAllowThreads(__tstate);
6362 if (PyErr_Occurred()) SWIG_fail;
6363 }
6364 resultobj = SWIG_From_int(static_cast< int >(result));
6365 return resultobj;
6366 fail:
6367 return NULL;
6368 }
6369
6370
6371 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6372 PyObject *resultobj = 0;
6373 wxRect *arg1 = (wxRect *) 0 ;
6374 int arg2 ;
6375 void *argp1 = 0 ;
6376 int res1 = 0 ;
6377 int val2 ;
6378 int ecode2 = 0 ;
6379 PyObject * obj0 = 0 ;
6380 PyObject * obj1 = 0 ;
6381 char * kwnames[] = {
6382 (char *) "self",(char *) "y", NULL
6383 };
6384
6385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6387 if (!SWIG_IsOK(res1)) {
6388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6389 }
6390 arg1 = reinterpret_cast< wxRect * >(argp1);
6391 ecode2 = SWIG_AsVal_int(obj1, &val2);
6392 if (!SWIG_IsOK(ecode2)) {
6393 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6394 }
6395 arg2 = static_cast< int >(val2);
6396 {
6397 PyThreadState* __tstate = wxPyBeginAllowThreads();
6398 (arg1)->SetY(arg2);
6399 wxPyEndAllowThreads(__tstate);
6400 if (PyErr_Occurred()) SWIG_fail;
6401 }
6402 resultobj = SWIG_Py_Void();
6403 return resultobj;
6404 fail:
6405 return NULL;
6406 }
6407
6408
6409 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6410 PyObject *resultobj = 0;
6411 wxRect *arg1 = (wxRect *) 0 ;
6412 int result;
6413 void *argp1 = 0 ;
6414 int res1 = 0 ;
6415 PyObject *swig_obj[1] ;
6416
6417 if (!args) SWIG_fail;
6418 swig_obj[0] = args;
6419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6420 if (!SWIG_IsOK(res1)) {
6421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6422 }
6423 arg1 = reinterpret_cast< wxRect * >(argp1);
6424 {
6425 PyThreadState* __tstate = wxPyBeginAllowThreads();
6426 result = (int)((wxRect const *)arg1)->GetWidth();
6427 wxPyEndAllowThreads(__tstate);
6428 if (PyErr_Occurred()) SWIG_fail;
6429 }
6430 resultobj = SWIG_From_int(static_cast< int >(result));
6431 return resultobj;
6432 fail:
6433 return NULL;
6434 }
6435
6436
6437 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6438 PyObject *resultobj = 0;
6439 wxRect *arg1 = (wxRect *) 0 ;
6440 int arg2 ;
6441 void *argp1 = 0 ;
6442 int res1 = 0 ;
6443 int val2 ;
6444 int ecode2 = 0 ;
6445 PyObject * obj0 = 0 ;
6446 PyObject * obj1 = 0 ;
6447 char * kwnames[] = {
6448 (char *) "self",(char *) "w", NULL
6449 };
6450
6451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6453 if (!SWIG_IsOK(res1)) {
6454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6455 }
6456 arg1 = reinterpret_cast< wxRect * >(argp1);
6457 ecode2 = SWIG_AsVal_int(obj1, &val2);
6458 if (!SWIG_IsOK(ecode2)) {
6459 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6460 }
6461 arg2 = static_cast< int >(val2);
6462 {
6463 PyThreadState* __tstate = wxPyBeginAllowThreads();
6464 (arg1)->SetWidth(arg2);
6465 wxPyEndAllowThreads(__tstate);
6466 if (PyErr_Occurred()) SWIG_fail;
6467 }
6468 resultobj = SWIG_Py_Void();
6469 return resultobj;
6470 fail:
6471 return NULL;
6472 }
6473
6474
6475 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6476 PyObject *resultobj = 0;
6477 wxRect *arg1 = (wxRect *) 0 ;
6478 int result;
6479 void *argp1 = 0 ;
6480 int res1 = 0 ;
6481 PyObject *swig_obj[1] ;
6482
6483 if (!args) SWIG_fail;
6484 swig_obj[0] = args;
6485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6486 if (!SWIG_IsOK(res1)) {
6487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6488 }
6489 arg1 = reinterpret_cast< wxRect * >(argp1);
6490 {
6491 PyThreadState* __tstate = wxPyBeginAllowThreads();
6492 result = (int)((wxRect const *)arg1)->GetHeight();
6493 wxPyEndAllowThreads(__tstate);
6494 if (PyErr_Occurred()) SWIG_fail;
6495 }
6496 resultobj = SWIG_From_int(static_cast< int >(result));
6497 return resultobj;
6498 fail:
6499 return NULL;
6500 }
6501
6502
6503 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6504 PyObject *resultobj = 0;
6505 wxRect *arg1 = (wxRect *) 0 ;
6506 int arg2 ;
6507 void *argp1 = 0 ;
6508 int res1 = 0 ;
6509 int val2 ;
6510 int ecode2 = 0 ;
6511 PyObject * obj0 = 0 ;
6512 PyObject * obj1 = 0 ;
6513 char * kwnames[] = {
6514 (char *) "self",(char *) "h", NULL
6515 };
6516
6517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6519 if (!SWIG_IsOK(res1)) {
6520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6521 }
6522 arg1 = reinterpret_cast< wxRect * >(argp1);
6523 ecode2 = SWIG_AsVal_int(obj1, &val2);
6524 if (!SWIG_IsOK(ecode2)) {
6525 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6526 }
6527 arg2 = static_cast< int >(val2);
6528 {
6529 PyThreadState* __tstate = wxPyBeginAllowThreads();
6530 (arg1)->SetHeight(arg2);
6531 wxPyEndAllowThreads(__tstate);
6532 if (PyErr_Occurred()) SWIG_fail;
6533 }
6534 resultobj = SWIG_Py_Void();
6535 return resultobj;
6536 fail:
6537 return NULL;
6538 }
6539
6540
6541 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6542 PyObject *resultobj = 0;
6543 wxRect *arg1 = (wxRect *) 0 ;
6544 wxPoint result;
6545 void *argp1 = 0 ;
6546 int res1 = 0 ;
6547 PyObject *swig_obj[1] ;
6548
6549 if (!args) SWIG_fail;
6550 swig_obj[0] = args;
6551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6552 if (!SWIG_IsOK(res1)) {
6553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6554 }
6555 arg1 = reinterpret_cast< wxRect * >(argp1);
6556 {
6557 PyThreadState* __tstate = wxPyBeginAllowThreads();
6558 result = ((wxRect const *)arg1)->GetPosition();
6559 wxPyEndAllowThreads(__tstate);
6560 if (PyErr_Occurred()) SWIG_fail;
6561 }
6562 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6563 return resultobj;
6564 fail:
6565 return NULL;
6566 }
6567
6568
6569 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6570 PyObject *resultobj = 0;
6571 wxRect *arg1 = (wxRect *) 0 ;
6572 wxPoint *arg2 = 0 ;
6573 void *argp1 = 0 ;
6574 int res1 = 0 ;
6575 wxPoint temp2 ;
6576 PyObject * obj0 = 0 ;
6577 PyObject * obj1 = 0 ;
6578 char * kwnames[] = {
6579 (char *) "self",(char *) "p", NULL
6580 };
6581
6582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6584 if (!SWIG_IsOK(res1)) {
6585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6586 }
6587 arg1 = reinterpret_cast< wxRect * >(argp1);
6588 {
6589 arg2 = &temp2;
6590 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6591 }
6592 {
6593 PyThreadState* __tstate = wxPyBeginAllowThreads();
6594 (arg1)->SetPosition((wxPoint const &)*arg2);
6595 wxPyEndAllowThreads(__tstate);
6596 if (PyErr_Occurred()) SWIG_fail;
6597 }
6598 resultobj = SWIG_Py_Void();
6599 return resultobj;
6600 fail:
6601 return NULL;
6602 }
6603
6604
6605 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6606 PyObject *resultobj = 0;
6607 wxRect *arg1 = (wxRect *) 0 ;
6608 wxSize result;
6609 void *argp1 = 0 ;
6610 int res1 = 0 ;
6611 PyObject *swig_obj[1] ;
6612
6613 if (!args) SWIG_fail;
6614 swig_obj[0] = args;
6615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6616 if (!SWIG_IsOK(res1)) {
6617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6618 }
6619 arg1 = reinterpret_cast< wxRect * >(argp1);
6620 {
6621 PyThreadState* __tstate = wxPyBeginAllowThreads();
6622 result = ((wxRect const *)arg1)->GetSize();
6623 wxPyEndAllowThreads(__tstate);
6624 if (PyErr_Occurred()) SWIG_fail;
6625 }
6626 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6627 return resultobj;
6628 fail:
6629 return NULL;
6630 }
6631
6632
6633 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6634 PyObject *resultobj = 0;
6635 wxRect *arg1 = (wxRect *) 0 ;
6636 wxSize *arg2 = 0 ;
6637 void *argp1 = 0 ;
6638 int res1 = 0 ;
6639 wxSize temp2 ;
6640 PyObject * obj0 = 0 ;
6641 PyObject * obj1 = 0 ;
6642 char * kwnames[] = {
6643 (char *) "self",(char *) "s", NULL
6644 };
6645
6646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6648 if (!SWIG_IsOK(res1)) {
6649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6650 }
6651 arg1 = reinterpret_cast< wxRect * >(argp1);
6652 {
6653 arg2 = &temp2;
6654 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6655 }
6656 {
6657 PyThreadState* __tstate = wxPyBeginAllowThreads();
6658 (arg1)->SetSize((wxSize const &)*arg2);
6659 wxPyEndAllowThreads(__tstate);
6660 if (PyErr_Occurred()) SWIG_fail;
6661 }
6662 resultobj = SWIG_Py_Void();
6663 return resultobj;
6664 fail:
6665 return NULL;
6666 }
6667
6668
6669 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6670 PyObject *resultobj = 0;
6671 wxRect *arg1 = (wxRect *) 0 ;
6672 bool result;
6673 void *argp1 = 0 ;
6674 int res1 = 0 ;
6675 PyObject *swig_obj[1] ;
6676
6677 if (!args) SWIG_fail;
6678 swig_obj[0] = args;
6679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6680 if (!SWIG_IsOK(res1)) {
6681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6682 }
6683 arg1 = reinterpret_cast< wxRect * >(argp1);
6684 {
6685 PyThreadState* __tstate = wxPyBeginAllowThreads();
6686 result = (bool)((wxRect const *)arg1)->IsEmpty();
6687 wxPyEndAllowThreads(__tstate);
6688 if (PyErr_Occurred()) SWIG_fail;
6689 }
6690 {
6691 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6692 }
6693 return resultobj;
6694 fail:
6695 return NULL;
6696 }
6697
6698
6699 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6700 PyObject *resultobj = 0;
6701 wxRect *arg1 = (wxRect *) 0 ;
6702 wxPoint result;
6703 void *argp1 = 0 ;
6704 int res1 = 0 ;
6705 PyObject *swig_obj[1] ;
6706
6707 if (!args) SWIG_fail;
6708 swig_obj[0] = args;
6709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6710 if (!SWIG_IsOK(res1)) {
6711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6712 }
6713 arg1 = reinterpret_cast< wxRect * >(argp1);
6714 {
6715 PyThreadState* __tstate = wxPyBeginAllowThreads();
6716 result = ((wxRect const *)arg1)->GetTopLeft();
6717 wxPyEndAllowThreads(__tstate);
6718 if (PyErr_Occurred()) SWIG_fail;
6719 }
6720 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6721 return resultobj;
6722 fail:
6723 return NULL;
6724 }
6725
6726
6727 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6728 PyObject *resultobj = 0;
6729 wxRect *arg1 = (wxRect *) 0 ;
6730 wxPoint *arg2 = 0 ;
6731 void *argp1 = 0 ;
6732 int res1 = 0 ;
6733 wxPoint temp2 ;
6734 PyObject * obj0 = 0 ;
6735 PyObject * obj1 = 0 ;
6736 char * kwnames[] = {
6737 (char *) "self",(char *) "p", NULL
6738 };
6739
6740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6742 if (!SWIG_IsOK(res1)) {
6743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6744 }
6745 arg1 = reinterpret_cast< wxRect * >(argp1);
6746 {
6747 arg2 = &temp2;
6748 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6749 }
6750 {
6751 PyThreadState* __tstate = wxPyBeginAllowThreads();
6752 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6753 wxPyEndAllowThreads(__tstate);
6754 if (PyErr_Occurred()) SWIG_fail;
6755 }
6756 resultobj = SWIG_Py_Void();
6757 return resultobj;
6758 fail:
6759 return NULL;
6760 }
6761
6762
6763 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6764 PyObject *resultobj = 0;
6765 wxRect *arg1 = (wxRect *) 0 ;
6766 wxPoint result;
6767 void *argp1 = 0 ;
6768 int res1 = 0 ;
6769 PyObject *swig_obj[1] ;
6770
6771 if (!args) SWIG_fail;
6772 swig_obj[0] = args;
6773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6774 if (!SWIG_IsOK(res1)) {
6775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6776 }
6777 arg1 = reinterpret_cast< wxRect * >(argp1);
6778 {
6779 PyThreadState* __tstate = wxPyBeginAllowThreads();
6780 result = ((wxRect const *)arg1)->GetBottomRight();
6781 wxPyEndAllowThreads(__tstate);
6782 if (PyErr_Occurred()) SWIG_fail;
6783 }
6784 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6785 return resultobj;
6786 fail:
6787 return NULL;
6788 }
6789
6790
6791 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6792 PyObject *resultobj = 0;
6793 wxRect *arg1 = (wxRect *) 0 ;
6794 wxPoint *arg2 = 0 ;
6795 void *argp1 = 0 ;
6796 int res1 = 0 ;
6797 wxPoint temp2 ;
6798 PyObject * obj0 = 0 ;
6799 PyObject * obj1 = 0 ;
6800 char * kwnames[] = {
6801 (char *) "self",(char *) "p", NULL
6802 };
6803
6804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6806 if (!SWIG_IsOK(res1)) {
6807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6808 }
6809 arg1 = reinterpret_cast< wxRect * >(argp1);
6810 {
6811 arg2 = &temp2;
6812 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6813 }
6814 {
6815 PyThreadState* __tstate = wxPyBeginAllowThreads();
6816 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6817 wxPyEndAllowThreads(__tstate);
6818 if (PyErr_Occurred()) SWIG_fail;
6819 }
6820 resultobj = SWIG_Py_Void();
6821 return resultobj;
6822 fail:
6823 return NULL;
6824 }
6825
6826
6827 SWIGINTERN PyObject *_wrap_Rect_GetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6828 PyObject *resultobj = 0;
6829 wxRect *arg1 = (wxRect *) 0 ;
6830 wxPoint result;
6831 void *argp1 = 0 ;
6832 int res1 = 0 ;
6833 PyObject *swig_obj[1] ;
6834
6835 if (!args) SWIG_fail;
6836 swig_obj[0] = args;
6837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6838 if (!SWIG_IsOK(res1)) {
6839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6840 }
6841 arg1 = reinterpret_cast< wxRect * >(argp1);
6842 {
6843 PyThreadState* __tstate = wxPyBeginAllowThreads();
6844 result = ((wxRect const *)arg1)->GetTopRight();
6845 wxPyEndAllowThreads(__tstate);
6846 if (PyErr_Occurred()) SWIG_fail;
6847 }
6848 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6849 return resultobj;
6850 fail:
6851 return NULL;
6852 }
6853
6854
6855 SWIGINTERN PyObject *_wrap_Rect_SetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6856 PyObject *resultobj = 0;
6857 wxRect *arg1 = (wxRect *) 0 ;
6858 wxPoint *arg2 = 0 ;
6859 void *argp1 = 0 ;
6860 int res1 = 0 ;
6861 wxPoint temp2 ;
6862 PyObject * obj0 = 0 ;
6863 PyObject * obj1 = 0 ;
6864 char * kwnames[] = {
6865 (char *) "self",(char *) "p", NULL
6866 };
6867
6868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopRight",kwnames,&obj0,&obj1)) SWIG_fail;
6869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6870 if (!SWIG_IsOK(res1)) {
6871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopRight" "', expected argument " "1"" of type '" "wxRect *""'");
6872 }
6873 arg1 = reinterpret_cast< wxRect * >(argp1);
6874 {
6875 arg2 = &temp2;
6876 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6877 }
6878 {
6879 PyThreadState* __tstate = wxPyBeginAllowThreads();
6880 (arg1)->SetTopRight((wxPoint const &)*arg2);
6881 wxPyEndAllowThreads(__tstate);
6882 if (PyErr_Occurred()) SWIG_fail;
6883 }
6884 resultobj = SWIG_Py_Void();
6885 return resultobj;
6886 fail:
6887 return NULL;
6888 }
6889
6890
6891 SWIGINTERN PyObject *_wrap_Rect_GetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6892 PyObject *resultobj = 0;
6893 wxRect *arg1 = (wxRect *) 0 ;
6894 wxPoint result;
6895 void *argp1 = 0 ;
6896 int res1 = 0 ;
6897 PyObject *swig_obj[1] ;
6898
6899 if (!args) SWIG_fail;
6900 swig_obj[0] = args;
6901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6902 if (!SWIG_IsOK(res1)) {
6903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6904 }
6905 arg1 = reinterpret_cast< wxRect * >(argp1);
6906 {
6907 PyThreadState* __tstate = wxPyBeginAllowThreads();
6908 result = ((wxRect const *)arg1)->GetBottomLeft();
6909 wxPyEndAllowThreads(__tstate);
6910 if (PyErr_Occurred()) SWIG_fail;
6911 }
6912 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6913 return resultobj;
6914 fail:
6915 return NULL;
6916 }
6917
6918
6919 SWIGINTERN PyObject *_wrap_Rect_SetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6920 PyObject *resultobj = 0;
6921 wxRect *arg1 = (wxRect *) 0 ;
6922 wxPoint *arg2 = 0 ;
6923 void *argp1 = 0 ;
6924 int res1 = 0 ;
6925 wxPoint temp2 ;
6926 PyObject * obj0 = 0 ;
6927 PyObject * obj1 = 0 ;
6928 char * kwnames[] = {
6929 (char *) "self",(char *) "p", NULL
6930 };
6931
6932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6934 if (!SWIG_IsOK(res1)) {
6935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6936 }
6937 arg1 = reinterpret_cast< wxRect * >(argp1);
6938 {
6939 arg2 = &temp2;
6940 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6941 }
6942 {
6943 PyThreadState* __tstate = wxPyBeginAllowThreads();
6944 (arg1)->SetBottomLeft((wxPoint const &)*arg2);
6945 wxPyEndAllowThreads(__tstate);
6946 if (PyErr_Occurred()) SWIG_fail;
6947 }
6948 resultobj = SWIG_Py_Void();
6949 return resultobj;
6950 fail:
6951 return NULL;
6952 }
6953
6954
6955 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6956 PyObject *resultobj = 0;
6957 wxRect *arg1 = (wxRect *) 0 ;
6958 int result;
6959 void *argp1 = 0 ;
6960 int res1 = 0 ;
6961 PyObject *swig_obj[1] ;
6962
6963 if (!args) SWIG_fail;
6964 swig_obj[0] = args;
6965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6966 if (!SWIG_IsOK(res1)) {
6967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6968 }
6969 arg1 = reinterpret_cast< wxRect * >(argp1);
6970 {
6971 PyThreadState* __tstate = wxPyBeginAllowThreads();
6972 result = (int)((wxRect const *)arg1)->GetLeft();
6973 wxPyEndAllowThreads(__tstate);
6974 if (PyErr_Occurred()) SWIG_fail;
6975 }
6976 resultobj = SWIG_From_int(static_cast< int >(result));
6977 return resultobj;
6978 fail:
6979 return NULL;
6980 }
6981
6982
6983 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6984 PyObject *resultobj = 0;
6985 wxRect *arg1 = (wxRect *) 0 ;
6986 int result;
6987 void *argp1 = 0 ;
6988 int res1 = 0 ;
6989 PyObject *swig_obj[1] ;
6990
6991 if (!args) SWIG_fail;
6992 swig_obj[0] = args;
6993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6994 if (!SWIG_IsOK(res1)) {
6995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
6996 }
6997 arg1 = reinterpret_cast< wxRect * >(argp1);
6998 {
6999 PyThreadState* __tstate = wxPyBeginAllowThreads();
7000 result = (int)((wxRect const *)arg1)->GetTop();
7001 wxPyEndAllowThreads(__tstate);
7002 if (PyErr_Occurred()) SWIG_fail;
7003 }
7004 resultobj = SWIG_From_int(static_cast< int >(result));
7005 return resultobj;
7006 fail:
7007 return NULL;
7008 }
7009
7010
7011 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7012 PyObject *resultobj = 0;
7013 wxRect *arg1 = (wxRect *) 0 ;
7014 int result;
7015 void *argp1 = 0 ;
7016 int res1 = 0 ;
7017 PyObject *swig_obj[1] ;
7018
7019 if (!args) SWIG_fail;
7020 swig_obj[0] = args;
7021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7022 if (!SWIG_IsOK(res1)) {
7023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
7024 }
7025 arg1 = reinterpret_cast< wxRect * >(argp1);
7026 {
7027 PyThreadState* __tstate = wxPyBeginAllowThreads();
7028 result = (int)((wxRect const *)arg1)->GetBottom();
7029 wxPyEndAllowThreads(__tstate);
7030 if (PyErr_Occurred()) SWIG_fail;
7031 }
7032 resultobj = SWIG_From_int(static_cast< int >(result));
7033 return resultobj;
7034 fail:
7035 return NULL;
7036 }
7037
7038
7039 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7040 PyObject *resultobj = 0;
7041 wxRect *arg1 = (wxRect *) 0 ;
7042 int result;
7043 void *argp1 = 0 ;
7044 int res1 = 0 ;
7045 PyObject *swig_obj[1] ;
7046
7047 if (!args) SWIG_fail;
7048 swig_obj[0] = args;
7049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7050 if (!SWIG_IsOK(res1)) {
7051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
7052 }
7053 arg1 = reinterpret_cast< wxRect * >(argp1);
7054 {
7055 PyThreadState* __tstate = wxPyBeginAllowThreads();
7056 result = (int)((wxRect const *)arg1)->GetRight();
7057 wxPyEndAllowThreads(__tstate);
7058 if (PyErr_Occurred()) SWIG_fail;
7059 }
7060 resultobj = SWIG_From_int(static_cast< int >(result));
7061 return resultobj;
7062 fail:
7063 return NULL;
7064 }
7065
7066
7067 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7068 PyObject *resultobj = 0;
7069 wxRect *arg1 = (wxRect *) 0 ;
7070 int arg2 ;
7071 void *argp1 = 0 ;
7072 int res1 = 0 ;
7073 int val2 ;
7074 int ecode2 = 0 ;
7075 PyObject * obj0 = 0 ;
7076 PyObject * obj1 = 0 ;
7077 char * kwnames[] = {
7078 (char *) "self",(char *) "left", NULL
7079 };
7080
7081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7083 if (!SWIG_IsOK(res1)) {
7084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7085 }
7086 arg1 = reinterpret_cast< wxRect * >(argp1);
7087 ecode2 = SWIG_AsVal_int(obj1, &val2);
7088 if (!SWIG_IsOK(ecode2)) {
7089 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
7090 }
7091 arg2 = static_cast< int >(val2);
7092 {
7093 PyThreadState* __tstate = wxPyBeginAllowThreads();
7094 (arg1)->SetLeft(arg2);
7095 wxPyEndAllowThreads(__tstate);
7096 if (PyErr_Occurred()) SWIG_fail;
7097 }
7098 resultobj = SWIG_Py_Void();
7099 return resultobj;
7100 fail:
7101 return NULL;
7102 }
7103
7104
7105 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7106 PyObject *resultobj = 0;
7107 wxRect *arg1 = (wxRect *) 0 ;
7108 int arg2 ;
7109 void *argp1 = 0 ;
7110 int res1 = 0 ;
7111 int val2 ;
7112 int ecode2 = 0 ;
7113 PyObject * obj0 = 0 ;
7114 PyObject * obj1 = 0 ;
7115 char * kwnames[] = {
7116 (char *) "self",(char *) "right", NULL
7117 };
7118
7119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
7120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7121 if (!SWIG_IsOK(res1)) {
7122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
7123 }
7124 arg1 = reinterpret_cast< wxRect * >(argp1);
7125 ecode2 = SWIG_AsVal_int(obj1, &val2);
7126 if (!SWIG_IsOK(ecode2)) {
7127 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
7128 }
7129 arg2 = static_cast< int >(val2);
7130 {
7131 PyThreadState* __tstate = wxPyBeginAllowThreads();
7132 (arg1)->SetRight(arg2);
7133 wxPyEndAllowThreads(__tstate);
7134 if (PyErr_Occurred()) SWIG_fail;
7135 }
7136 resultobj = SWIG_Py_Void();
7137 return resultobj;
7138 fail:
7139 return NULL;
7140 }
7141
7142
7143 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7144 PyObject *resultobj = 0;
7145 wxRect *arg1 = (wxRect *) 0 ;
7146 int arg2 ;
7147 void *argp1 = 0 ;
7148 int res1 = 0 ;
7149 int val2 ;
7150 int ecode2 = 0 ;
7151 PyObject * obj0 = 0 ;
7152 PyObject * obj1 = 0 ;
7153 char * kwnames[] = {
7154 (char *) "self",(char *) "top", NULL
7155 };
7156
7157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7159 if (!SWIG_IsOK(res1)) {
7160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7161 }
7162 arg1 = reinterpret_cast< wxRect * >(argp1);
7163 ecode2 = SWIG_AsVal_int(obj1, &val2);
7164 if (!SWIG_IsOK(ecode2)) {
7165 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7166 }
7167 arg2 = static_cast< int >(val2);
7168 {
7169 PyThreadState* __tstate = wxPyBeginAllowThreads();
7170 (arg1)->SetTop(arg2);
7171 wxPyEndAllowThreads(__tstate);
7172 if (PyErr_Occurred()) SWIG_fail;
7173 }
7174 resultobj = SWIG_Py_Void();
7175 return resultobj;
7176 fail:
7177 return NULL;
7178 }
7179
7180
7181 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7182 PyObject *resultobj = 0;
7183 wxRect *arg1 = (wxRect *) 0 ;
7184 int arg2 ;
7185 void *argp1 = 0 ;
7186 int res1 = 0 ;
7187 int val2 ;
7188 int ecode2 = 0 ;
7189 PyObject * obj0 = 0 ;
7190 PyObject * obj1 = 0 ;
7191 char * kwnames[] = {
7192 (char *) "self",(char *) "bottom", NULL
7193 };
7194
7195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7197 if (!SWIG_IsOK(res1)) {
7198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7199 }
7200 arg1 = reinterpret_cast< wxRect * >(argp1);
7201 ecode2 = SWIG_AsVal_int(obj1, &val2);
7202 if (!SWIG_IsOK(ecode2)) {
7203 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7204 }
7205 arg2 = static_cast< int >(val2);
7206 {
7207 PyThreadState* __tstate = wxPyBeginAllowThreads();
7208 (arg1)->SetBottom(arg2);
7209 wxPyEndAllowThreads(__tstate);
7210 if (PyErr_Occurred()) SWIG_fail;
7211 }
7212 resultobj = SWIG_Py_Void();
7213 return resultobj;
7214 fail:
7215 return NULL;
7216 }
7217
7218
7219 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7220 PyObject *resultobj = 0;
7221 wxRect *arg1 = (wxRect *) 0 ;
7222 int arg2 ;
7223 int arg3 ;
7224 wxRect *result = 0 ;
7225 void *argp1 = 0 ;
7226 int res1 = 0 ;
7227 int val2 ;
7228 int ecode2 = 0 ;
7229 int val3 ;
7230 int ecode3 = 0 ;
7231 PyObject * obj0 = 0 ;
7232 PyObject * obj1 = 0 ;
7233 PyObject * obj2 = 0 ;
7234 char * kwnames[] = {
7235 (char *) "self",(char *) "dx",(char *) "dy", NULL
7236 };
7237
7238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7240 if (!SWIG_IsOK(res1)) {
7241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7242 }
7243 arg1 = reinterpret_cast< wxRect * >(argp1);
7244 ecode2 = SWIG_AsVal_int(obj1, &val2);
7245 if (!SWIG_IsOK(ecode2)) {
7246 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7247 }
7248 arg2 = static_cast< int >(val2);
7249 ecode3 = SWIG_AsVal_int(obj2, &val3);
7250 if (!SWIG_IsOK(ecode3)) {
7251 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7252 }
7253 arg3 = static_cast< int >(val3);
7254 {
7255 PyThreadState* __tstate = wxPyBeginAllowThreads();
7256 {
7257 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7258 result = (wxRect *) &_result_ref;
7259 }
7260 wxPyEndAllowThreads(__tstate);
7261 if (PyErr_Occurred()) SWIG_fail;
7262 }
7263 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7264 return resultobj;
7265 fail:
7266 return NULL;
7267 }
7268
7269
7270 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7271 PyObject *resultobj = 0;
7272 wxRect *arg1 = (wxRect *) 0 ;
7273 int arg2 ;
7274 int arg3 ;
7275 wxRect *result = 0 ;
7276 void *argp1 = 0 ;
7277 int res1 = 0 ;
7278 int val2 ;
7279 int ecode2 = 0 ;
7280 int val3 ;
7281 int ecode3 = 0 ;
7282 PyObject * obj0 = 0 ;
7283 PyObject * obj1 = 0 ;
7284 PyObject * obj2 = 0 ;
7285 char * kwnames[] = {
7286 (char *) "self",(char *) "dx",(char *) "dy", NULL
7287 };
7288
7289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7291 if (!SWIG_IsOK(res1)) {
7292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7293 }
7294 arg1 = reinterpret_cast< wxRect * >(argp1);
7295 ecode2 = SWIG_AsVal_int(obj1, &val2);
7296 if (!SWIG_IsOK(ecode2)) {
7297 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7298 }
7299 arg2 = static_cast< int >(val2);
7300 ecode3 = SWIG_AsVal_int(obj2, &val3);
7301 if (!SWIG_IsOK(ecode3)) {
7302 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7303 }
7304 arg3 = static_cast< int >(val3);
7305 {
7306 PyThreadState* __tstate = wxPyBeginAllowThreads();
7307 {
7308 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7309 result = (wxRect *) &_result_ref;
7310 }
7311 wxPyEndAllowThreads(__tstate);
7312 if (PyErr_Occurred()) SWIG_fail;
7313 }
7314 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7315 return resultobj;
7316 fail:
7317 return NULL;
7318 }
7319
7320
7321 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7322 PyObject *resultobj = 0;
7323 wxRect *arg1 = (wxRect *) 0 ;
7324 int arg2 ;
7325 int arg3 ;
7326 void *argp1 = 0 ;
7327 int res1 = 0 ;
7328 int val2 ;
7329 int ecode2 = 0 ;
7330 int val3 ;
7331 int ecode3 = 0 ;
7332 PyObject * obj0 = 0 ;
7333 PyObject * obj1 = 0 ;
7334 PyObject * obj2 = 0 ;
7335 char * kwnames[] = {
7336 (char *) "self",(char *) "dx",(char *) "dy", NULL
7337 };
7338
7339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7341 if (!SWIG_IsOK(res1)) {
7342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7343 }
7344 arg1 = reinterpret_cast< wxRect * >(argp1);
7345 ecode2 = SWIG_AsVal_int(obj1, &val2);
7346 if (!SWIG_IsOK(ecode2)) {
7347 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7348 }
7349 arg2 = static_cast< int >(val2);
7350 ecode3 = SWIG_AsVal_int(obj2, &val3);
7351 if (!SWIG_IsOK(ecode3)) {
7352 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7353 }
7354 arg3 = static_cast< int >(val3);
7355 {
7356 PyThreadState* __tstate = wxPyBeginAllowThreads();
7357 (arg1)->Offset(arg2,arg3);
7358 wxPyEndAllowThreads(__tstate);
7359 if (PyErr_Occurred()) SWIG_fail;
7360 }
7361 resultobj = SWIG_Py_Void();
7362 return resultobj;
7363 fail:
7364 return NULL;
7365 }
7366
7367
7368 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7369 PyObject *resultobj = 0;
7370 wxRect *arg1 = (wxRect *) 0 ;
7371 wxPoint *arg2 = 0 ;
7372 void *argp1 = 0 ;
7373 int res1 = 0 ;
7374 wxPoint temp2 ;
7375 PyObject * obj0 = 0 ;
7376 PyObject * obj1 = 0 ;
7377 char * kwnames[] = {
7378 (char *) "self",(char *) "pt", NULL
7379 };
7380
7381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7383 if (!SWIG_IsOK(res1)) {
7384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7385 }
7386 arg1 = reinterpret_cast< wxRect * >(argp1);
7387 {
7388 arg2 = &temp2;
7389 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7390 }
7391 {
7392 PyThreadState* __tstate = wxPyBeginAllowThreads();
7393 (arg1)->Offset((wxPoint const &)*arg2);
7394 wxPyEndAllowThreads(__tstate);
7395 if (PyErr_Occurred()) SWIG_fail;
7396 }
7397 resultobj = SWIG_Py_Void();
7398 return resultobj;
7399 fail:
7400 return NULL;
7401 }
7402
7403
7404 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7405 PyObject *resultobj = 0;
7406 wxRect *arg1 = (wxRect *) 0 ;
7407 wxRect *arg2 = 0 ;
7408 wxRect result;
7409 void *argp1 = 0 ;
7410 int res1 = 0 ;
7411 wxRect temp2 ;
7412 PyObject * obj0 = 0 ;
7413 PyObject * obj1 = 0 ;
7414 char * kwnames[] = {
7415 (char *) "self",(char *) "rect", NULL
7416 };
7417
7418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7420 if (!SWIG_IsOK(res1)) {
7421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7422 }
7423 arg1 = reinterpret_cast< wxRect * >(argp1);
7424 {
7425 arg2 = &temp2;
7426 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7427 }
7428 {
7429 PyThreadState* __tstate = wxPyBeginAllowThreads();
7430 result = (arg1)->Intersect((wxRect const &)*arg2);
7431 wxPyEndAllowThreads(__tstate);
7432 if (PyErr_Occurred()) SWIG_fail;
7433 }
7434 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7435 return resultobj;
7436 fail:
7437 return NULL;
7438 }
7439
7440
7441 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7442 PyObject *resultobj = 0;
7443 wxRect *arg1 = (wxRect *) 0 ;
7444 wxRect *arg2 = 0 ;
7445 wxRect result;
7446 void *argp1 = 0 ;
7447 int res1 = 0 ;
7448 wxRect temp2 ;
7449 PyObject * obj0 = 0 ;
7450 PyObject * obj1 = 0 ;
7451 char * kwnames[] = {
7452 (char *) "self",(char *) "rect", NULL
7453 };
7454
7455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7457 if (!SWIG_IsOK(res1)) {
7458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7459 }
7460 arg1 = reinterpret_cast< wxRect * >(argp1);
7461 {
7462 arg2 = &temp2;
7463 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7464 }
7465 {
7466 PyThreadState* __tstate = wxPyBeginAllowThreads();
7467 result = (arg1)->Union((wxRect const &)*arg2);
7468 wxPyEndAllowThreads(__tstate);
7469 if (PyErr_Occurred()) SWIG_fail;
7470 }
7471 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7472 return resultobj;
7473 fail:
7474 return NULL;
7475 }
7476
7477
7478 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7479 PyObject *resultobj = 0;
7480 wxRect *arg1 = (wxRect *) 0 ;
7481 wxRect *arg2 = 0 ;
7482 wxRect result;
7483 void *argp1 = 0 ;
7484 int res1 = 0 ;
7485 wxRect temp2 ;
7486 PyObject * obj0 = 0 ;
7487 PyObject * obj1 = 0 ;
7488 char * kwnames[] = {
7489 (char *) "self",(char *) "rect", NULL
7490 };
7491
7492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7494 if (!SWIG_IsOK(res1)) {
7495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7496 }
7497 arg1 = reinterpret_cast< wxRect * >(argp1);
7498 {
7499 arg2 = &temp2;
7500 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7501 }
7502 {
7503 PyThreadState* __tstate = wxPyBeginAllowThreads();
7504 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7505 wxPyEndAllowThreads(__tstate);
7506 if (PyErr_Occurred()) SWIG_fail;
7507 }
7508 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7509 return resultobj;
7510 fail:
7511 return NULL;
7512 }
7513
7514
7515 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7516 PyObject *resultobj = 0;
7517 wxRect *arg1 = (wxRect *) 0 ;
7518 wxRect *arg2 = 0 ;
7519 wxRect *result = 0 ;
7520 void *argp1 = 0 ;
7521 int res1 = 0 ;
7522 wxRect temp2 ;
7523 PyObject * obj0 = 0 ;
7524 PyObject * obj1 = 0 ;
7525 char * kwnames[] = {
7526 (char *) "self",(char *) "rect", NULL
7527 };
7528
7529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7531 if (!SWIG_IsOK(res1)) {
7532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7533 }
7534 arg1 = reinterpret_cast< wxRect * >(argp1);
7535 {
7536 arg2 = &temp2;
7537 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7538 }
7539 {
7540 PyThreadState* __tstate = wxPyBeginAllowThreads();
7541 {
7542 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7543 result = (wxRect *) &_result_ref;
7544 }
7545 wxPyEndAllowThreads(__tstate);
7546 if (PyErr_Occurred()) SWIG_fail;
7547 }
7548 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7549 return resultobj;
7550 fail:
7551 return NULL;
7552 }
7553
7554
7555 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7556 PyObject *resultobj = 0;
7557 wxRect *arg1 = (wxRect *) 0 ;
7558 PyObject *arg2 = (PyObject *) 0 ;
7559 bool result;
7560 void *argp1 = 0 ;
7561 int res1 = 0 ;
7562 PyObject * obj0 = 0 ;
7563 PyObject * obj1 = 0 ;
7564 char * kwnames[] = {
7565 (char *) "self",(char *) "other", NULL
7566 };
7567
7568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",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___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7572 }
7573 arg1 = reinterpret_cast< wxRect * >(argp1);
7574 arg2 = obj1;
7575 {
7576 result = (bool)wxRect___eq__(arg1,arg2);
7577 if (PyErr_Occurred()) SWIG_fail;
7578 }
7579 {
7580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7581 }
7582 return resultobj;
7583 fail:
7584 return NULL;
7585 }
7586
7587
7588 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7589 PyObject *resultobj = 0;
7590 wxRect *arg1 = (wxRect *) 0 ;
7591 PyObject *arg2 = (PyObject *) 0 ;
7592 bool result;
7593 void *argp1 = 0 ;
7594 int res1 = 0 ;
7595 PyObject * obj0 = 0 ;
7596 PyObject * obj1 = 0 ;
7597 char * kwnames[] = {
7598 (char *) "self",(char *) "other", NULL
7599 };
7600
7601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7603 if (!SWIG_IsOK(res1)) {
7604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7605 }
7606 arg1 = reinterpret_cast< wxRect * >(argp1);
7607 arg2 = obj1;
7608 {
7609 result = (bool)wxRect___ne__(arg1,arg2);
7610 if (PyErr_Occurred()) SWIG_fail;
7611 }
7612 {
7613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7614 }
7615 return resultobj;
7616 fail:
7617 return NULL;
7618 }
7619
7620
7621 SWIGINTERN PyObject *_wrap_Rect_ContainsXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7622 PyObject *resultobj = 0;
7623 wxRect *arg1 = (wxRect *) 0 ;
7624 int arg2 ;
7625 int arg3 ;
7626 bool result;
7627 void *argp1 = 0 ;
7628 int res1 = 0 ;
7629 int val2 ;
7630 int ecode2 = 0 ;
7631 int val3 ;
7632 int ecode3 = 0 ;
7633 PyObject * obj0 = 0 ;
7634 PyObject * obj1 = 0 ;
7635 PyObject * obj2 = 0 ;
7636 char * kwnames[] = {
7637 (char *) "self",(char *) "x",(char *) "y", NULL
7638 };
7639
7640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_ContainsXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7642 if (!SWIG_IsOK(res1)) {
7643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7644 }
7645 arg1 = reinterpret_cast< wxRect * >(argp1);
7646 ecode2 = SWIG_AsVal_int(obj1, &val2);
7647 if (!SWIG_IsOK(ecode2)) {
7648 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_ContainsXY" "', expected argument " "2"" of type '" "int""'");
7649 }
7650 arg2 = static_cast< int >(val2);
7651 ecode3 = SWIG_AsVal_int(obj2, &val3);
7652 if (!SWIG_IsOK(ecode3)) {
7653 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_ContainsXY" "', expected argument " "3"" of type '" "int""'");
7654 }
7655 arg3 = static_cast< int >(val3);
7656 {
7657 PyThreadState* __tstate = wxPyBeginAllowThreads();
7658 result = (bool)((wxRect const *)arg1)->Contains(arg2,arg3);
7659 wxPyEndAllowThreads(__tstate);
7660 if (PyErr_Occurred()) SWIG_fail;
7661 }
7662 {
7663 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7664 }
7665 return resultobj;
7666 fail:
7667 return NULL;
7668 }
7669
7670
7671 SWIGINTERN PyObject *_wrap_Rect_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7672 PyObject *resultobj = 0;
7673 wxRect *arg1 = (wxRect *) 0 ;
7674 wxPoint *arg2 = 0 ;
7675 bool result;
7676 void *argp1 = 0 ;
7677 int res1 = 0 ;
7678 wxPoint temp2 ;
7679 PyObject * obj0 = 0 ;
7680 PyObject * obj1 = 0 ;
7681 char * kwnames[] = {
7682 (char *) "self",(char *) "pt", NULL
7683 };
7684
7685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
7686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7687 if (!SWIG_IsOK(res1)) {
7688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Contains" "', expected argument " "1"" of type '" "wxRect const *""'");
7689 }
7690 arg1 = reinterpret_cast< wxRect * >(argp1);
7691 {
7692 arg2 = &temp2;
7693 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7694 }
7695 {
7696 PyThreadState* __tstate = wxPyBeginAllowThreads();
7697 result = (bool)((wxRect const *)arg1)->Contains((wxPoint const &)*arg2);
7698 wxPyEndAllowThreads(__tstate);
7699 if (PyErr_Occurred()) SWIG_fail;
7700 }
7701 {
7702 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7703 }
7704 return resultobj;
7705 fail:
7706 return NULL;
7707 }
7708
7709
7710 SWIGINTERN PyObject *_wrap_Rect_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7711 PyObject *resultobj = 0;
7712 wxRect *arg1 = (wxRect *) 0 ;
7713 wxRect *arg2 = 0 ;
7714 bool result;
7715 void *argp1 = 0 ;
7716 int res1 = 0 ;
7717 wxRect temp2 ;
7718 PyObject * obj0 = 0 ;
7719 PyObject * obj1 = 0 ;
7720 char * kwnames[] = {
7721 (char *) "self",(char *) "rect", NULL
7722 };
7723
7724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
7725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7726 if (!SWIG_IsOK(res1)) {
7727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsRect" "', expected argument " "1"" of type '" "wxRect const *""'");
7728 }
7729 arg1 = reinterpret_cast< wxRect * >(argp1);
7730 {
7731 arg2 = &temp2;
7732 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7733 }
7734 {
7735 PyThreadState* __tstate = wxPyBeginAllowThreads();
7736 result = (bool)((wxRect const *)arg1)->Contains((wxRect const &)*arg2);
7737 wxPyEndAllowThreads(__tstate);
7738 if (PyErr_Occurred()) SWIG_fail;
7739 }
7740 {
7741 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7742 }
7743 return resultobj;
7744 fail:
7745 return NULL;
7746 }
7747
7748
7749 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7750 PyObject *resultobj = 0;
7751 wxRect *arg1 = (wxRect *) 0 ;
7752 wxRect *arg2 = 0 ;
7753 bool result;
7754 void *argp1 = 0 ;
7755 int res1 = 0 ;
7756 wxRect temp2 ;
7757 PyObject * obj0 = 0 ;
7758 PyObject * obj1 = 0 ;
7759 char * kwnames[] = {
7760 (char *) "self",(char *) "rect", NULL
7761 };
7762
7763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7765 if (!SWIG_IsOK(res1)) {
7766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7767 }
7768 arg1 = reinterpret_cast< wxRect * >(argp1);
7769 {
7770 arg2 = &temp2;
7771 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7772 }
7773 {
7774 PyThreadState* __tstate = wxPyBeginAllowThreads();
7775 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7776 wxPyEndAllowThreads(__tstate);
7777 if (PyErr_Occurred()) SWIG_fail;
7778 }
7779 {
7780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7781 }
7782 return resultobj;
7783 fail:
7784 return NULL;
7785 }
7786
7787
7788 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7789 PyObject *resultobj = 0;
7790 wxRect *arg1 = (wxRect *) 0 ;
7791 wxRect *arg2 = 0 ;
7792 int arg3 = (int) wxBOTH ;
7793 wxRect result;
7794 void *argp1 = 0 ;
7795 int res1 = 0 ;
7796 wxRect temp2 ;
7797 int val3 ;
7798 int ecode3 = 0 ;
7799 PyObject * obj0 = 0 ;
7800 PyObject * obj1 = 0 ;
7801 PyObject * obj2 = 0 ;
7802 char * kwnames[] = {
7803 (char *) "self",(char *) "r",(char *) "dir", NULL
7804 };
7805
7806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7808 if (!SWIG_IsOK(res1)) {
7809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7810 }
7811 arg1 = reinterpret_cast< wxRect * >(argp1);
7812 {
7813 arg2 = &temp2;
7814 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7815 }
7816 if (obj2) {
7817 ecode3 = SWIG_AsVal_int(obj2, &val3);
7818 if (!SWIG_IsOK(ecode3)) {
7819 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7820 }
7821 arg3 = static_cast< int >(val3);
7822 }
7823 {
7824 PyThreadState* __tstate = wxPyBeginAllowThreads();
7825 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7826 wxPyEndAllowThreads(__tstate);
7827 if (PyErr_Occurred()) SWIG_fail;
7828 }
7829 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7830 return resultobj;
7831 fail:
7832 return NULL;
7833 }
7834
7835
7836 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7837 PyObject *resultobj = 0;
7838 wxRect *arg1 = (wxRect *) 0 ;
7839 int arg2 ;
7840 void *argp1 = 0 ;
7841 int res1 = 0 ;
7842 int val2 ;
7843 int ecode2 = 0 ;
7844 PyObject *swig_obj[2] ;
7845
7846 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7848 if (!SWIG_IsOK(res1)) {
7849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7850 }
7851 arg1 = reinterpret_cast< wxRect * >(argp1);
7852 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7853 if (!SWIG_IsOK(ecode2)) {
7854 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7855 }
7856 arg2 = static_cast< int >(val2);
7857 if (arg1) (arg1)->x = arg2;
7858
7859 resultobj = SWIG_Py_Void();
7860 return resultobj;
7861 fail:
7862 return NULL;
7863 }
7864
7865
7866 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7867 PyObject *resultobj = 0;
7868 wxRect *arg1 = (wxRect *) 0 ;
7869 int result;
7870 void *argp1 = 0 ;
7871 int res1 = 0 ;
7872 PyObject *swig_obj[1] ;
7873
7874 if (!args) SWIG_fail;
7875 swig_obj[0] = args;
7876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7877 if (!SWIG_IsOK(res1)) {
7878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7879 }
7880 arg1 = reinterpret_cast< wxRect * >(argp1);
7881 result = (int) ((arg1)->x);
7882 resultobj = SWIG_From_int(static_cast< int >(result));
7883 return resultobj;
7884 fail:
7885 return NULL;
7886 }
7887
7888
7889 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7890 PyObject *resultobj = 0;
7891 wxRect *arg1 = (wxRect *) 0 ;
7892 int arg2 ;
7893 void *argp1 = 0 ;
7894 int res1 = 0 ;
7895 int val2 ;
7896 int ecode2 = 0 ;
7897 PyObject *swig_obj[2] ;
7898
7899 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7901 if (!SWIG_IsOK(res1)) {
7902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7903 }
7904 arg1 = reinterpret_cast< wxRect * >(argp1);
7905 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7906 if (!SWIG_IsOK(ecode2)) {
7907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7908 }
7909 arg2 = static_cast< int >(val2);
7910 if (arg1) (arg1)->y = arg2;
7911
7912 resultobj = SWIG_Py_Void();
7913 return resultobj;
7914 fail:
7915 return NULL;
7916 }
7917
7918
7919 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7920 PyObject *resultobj = 0;
7921 wxRect *arg1 = (wxRect *) 0 ;
7922 int result;
7923 void *argp1 = 0 ;
7924 int res1 = 0 ;
7925 PyObject *swig_obj[1] ;
7926
7927 if (!args) SWIG_fail;
7928 swig_obj[0] = args;
7929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7930 if (!SWIG_IsOK(res1)) {
7931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7932 }
7933 arg1 = reinterpret_cast< wxRect * >(argp1);
7934 result = (int) ((arg1)->y);
7935 resultobj = SWIG_From_int(static_cast< int >(result));
7936 return resultobj;
7937 fail:
7938 return NULL;
7939 }
7940
7941
7942 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7943 PyObject *resultobj = 0;
7944 wxRect *arg1 = (wxRect *) 0 ;
7945 int arg2 ;
7946 void *argp1 = 0 ;
7947 int res1 = 0 ;
7948 int val2 ;
7949 int ecode2 = 0 ;
7950 PyObject *swig_obj[2] ;
7951
7952 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7954 if (!SWIG_IsOK(res1)) {
7955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7956 }
7957 arg1 = reinterpret_cast< wxRect * >(argp1);
7958 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7959 if (!SWIG_IsOK(ecode2)) {
7960 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7961 }
7962 arg2 = static_cast< int >(val2);
7963 if (arg1) (arg1)->width = arg2;
7964
7965 resultobj = SWIG_Py_Void();
7966 return resultobj;
7967 fail:
7968 return NULL;
7969 }
7970
7971
7972 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7973 PyObject *resultobj = 0;
7974 wxRect *arg1 = (wxRect *) 0 ;
7975 int result;
7976 void *argp1 = 0 ;
7977 int res1 = 0 ;
7978 PyObject *swig_obj[1] ;
7979
7980 if (!args) SWIG_fail;
7981 swig_obj[0] = args;
7982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7983 if (!SWIG_IsOK(res1)) {
7984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7985 }
7986 arg1 = reinterpret_cast< wxRect * >(argp1);
7987 result = (int) ((arg1)->width);
7988 resultobj = SWIG_From_int(static_cast< int >(result));
7989 return resultobj;
7990 fail:
7991 return NULL;
7992 }
7993
7994
7995 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7996 PyObject *resultobj = 0;
7997 wxRect *arg1 = (wxRect *) 0 ;
7998 int arg2 ;
7999 void *argp1 = 0 ;
8000 int res1 = 0 ;
8001 int val2 ;
8002 int ecode2 = 0 ;
8003 PyObject *swig_obj[2] ;
8004
8005 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
8006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8007 if (!SWIG_IsOK(res1)) {
8008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
8009 }
8010 arg1 = reinterpret_cast< wxRect * >(argp1);
8011 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8012 if (!SWIG_IsOK(ecode2)) {
8013 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
8014 }
8015 arg2 = static_cast< int >(val2);
8016 if (arg1) (arg1)->height = arg2;
8017
8018 resultobj = SWIG_Py_Void();
8019 return resultobj;
8020 fail:
8021 return NULL;
8022 }
8023
8024
8025 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8026 PyObject *resultobj = 0;
8027 wxRect *arg1 = (wxRect *) 0 ;
8028 int result;
8029 void *argp1 = 0 ;
8030 int res1 = 0 ;
8031 PyObject *swig_obj[1] ;
8032
8033 if (!args) SWIG_fail;
8034 swig_obj[0] = args;
8035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8036 if (!SWIG_IsOK(res1)) {
8037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
8038 }
8039 arg1 = reinterpret_cast< wxRect * >(argp1);
8040 result = (int) ((arg1)->height);
8041 resultobj = SWIG_From_int(static_cast< int >(result));
8042 return resultobj;
8043 fail:
8044 return NULL;
8045 }
8046
8047
8048 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8049 PyObject *resultobj = 0;
8050 wxRect *arg1 = (wxRect *) 0 ;
8051 int arg2 = (int) 0 ;
8052 int arg3 = (int) 0 ;
8053 int arg4 = (int) 0 ;
8054 int arg5 = (int) 0 ;
8055 void *argp1 = 0 ;
8056 int res1 = 0 ;
8057 int val2 ;
8058 int ecode2 = 0 ;
8059 int val3 ;
8060 int ecode3 = 0 ;
8061 int val4 ;
8062 int ecode4 = 0 ;
8063 int val5 ;
8064 int ecode5 = 0 ;
8065 PyObject * obj0 = 0 ;
8066 PyObject * obj1 = 0 ;
8067 PyObject * obj2 = 0 ;
8068 PyObject * obj3 = 0 ;
8069 PyObject * obj4 = 0 ;
8070 char * kwnames[] = {
8071 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
8072 };
8073
8074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8076 if (!SWIG_IsOK(res1)) {
8077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
8078 }
8079 arg1 = reinterpret_cast< wxRect * >(argp1);
8080 if (obj1) {
8081 ecode2 = SWIG_AsVal_int(obj1, &val2);
8082 if (!SWIG_IsOK(ecode2)) {
8083 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
8084 }
8085 arg2 = static_cast< int >(val2);
8086 }
8087 if (obj2) {
8088 ecode3 = SWIG_AsVal_int(obj2, &val3);
8089 if (!SWIG_IsOK(ecode3)) {
8090 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
8091 }
8092 arg3 = static_cast< int >(val3);
8093 }
8094 if (obj3) {
8095 ecode4 = SWIG_AsVal_int(obj3, &val4);
8096 if (!SWIG_IsOK(ecode4)) {
8097 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
8098 }
8099 arg4 = static_cast< int >(val4);
8100 }
8101 if (obj4) {
8102 ecode5 = SWIG_AsVal_int(obj4, &val5);
8103 if (!SWIG_IsOK(ecode5)) {
8104 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
8105 }
8106 arg5 = static_cast< int >(val5);
8107 }
8108 {
8109 PyThreadState* __tstate = wxPyBeginAllowThreads();
8110 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
8111 wxPyEndAllowThreads(__tstate);
8112 if (PyErr_Occurred()) SWIG_fail;
8113 }
8114 resultobj = SWIG_Py_Void();
8115 return resultobj;
8116 fail:
8117 return NULL;
8118 }
8119
8120
8121 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8122 PyObject *resultobj = 0;
8123 wxRect *arg1 = (wxRect *) 0 ;
8124 PyObject *result = 0 ;
8125 void *argp1 = 0 ;
8126 int res1 = 0 ;
8127 PyObject *swig_obj[1] ;
8128
8129 if (!args) SWIG_fail;
8130 swig_obj[0] = args;
8131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8132 if (!SWIG_IsOK(res1)) {
8133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
8134 }
8135 arg1 = reinterpret_cast< wxRect * >(argp1);
8136 {
8137 PyThreadState* __tstate = wxPyBeginAllowThreads();
8138 result = (PyObject *)wxRect_Get(arg1);
8139 wxPyEndAllowThreads(__tstate);
8140 if (PyErr_Occurred()) SWIG_fail;
8141 }
8142 resultobj = result;
8143 return resultobj;
8144 fail:
8145 return NULL;
8146 }
8147
8148
8149 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8150 PyObject *obj;
8151 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8152 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
8153 return SWIG_Py_Void();
8154 }
8155
8156 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8157 return SWIG_Python_InitShadowInstance(args);
8158 }
8159
8160 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8161 PyObject *resultobj = 0;
8162 wxRect *arg1 = (wxRect *) 0 ;
8163 wxRect *arg2 = (wxRect *) 0 ;
8164 PyObject *result = 0 ;
8165 void *argp1 = 0 ;
8166 int res1 = 0 ;
8167 void *argp2 = 0 ;
8168 int res2 = 0 ;
8169 PyObject * obj0 = 0 ;
8170 PyObject * obj1 = 0 ;
8171 char * kwnames[] = {
8172 (char *) "r1",(char *) "r2", NULL
8173 };
8174
8175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
8176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8177 if (!SWIG_IsOK(res1)) {
8178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
8179 }
8180 arg1 = reinterpret_cast< wxRect * >(argp1);
8181 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
8182 if (!SWIG_IsOK(res2)) {
8183 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
8184 }
8185 arg2 = reinterpret_cast< wxRect * >(argp2);
8186 {
8187 if (!wxPyCheckForApp()) SWIG_fail;
8188 PyThreadState* __tstate = wxPyBeginAllowThreads();
8189 result = (PyObject *)wxIntersectRect(arg1,arg2);
8190 wxPyEndAllowThreads(__tstate);
8191 if (PyErr_Occurred()) SWIG_fail;
8192 }
8193 resultobj = result;
8194 return resultobj;
8195 fail:
8196 return NULL;
8197 }
8198
8199
8200 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8201 PyObject *resultobj = 0;
8202 double arg1 = (double) 0.0 ;
8203 double arg2 = (double) 0.0 ;
8204 wxPoint2D *result = 0 ;
8205 double val1 ;
8206 int ecode1 = 0 ;
8207 double val2 ;
8208 int ecode2 = 0 ;
8209 PyObject * obj0 = 0 ;
8210 PyObject * obj1 = 0 ;
8211 char * kwnames[] = {
8212 (char *) "x",(char *) "y", NULL
8213 };
8214
8215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8216 if (obj0) {
8217 ecode1 = SWIG_AsVal_double(obj0, &val1);
8218 if (!SWIG_IsOK(ecode1)) {
8219 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8220 }
8221 arg1 = static_cast< double >(val1);
8222 }
8223 if (obj1) {
8224 ecode2 = SWIG_AsVal_double(obj1, &val2);
8225 if (!SWIG_IsOK(ecode2)) {
8226 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8227 }
8228 arg2 = static_cast< double >(val2);
8229 }
8230 {
8231 PyThreadState* __tstate = wxPyBeginAllowThreads();
8232 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8233 wxPyEndAllowThreads(__tstate);
8234 if (PyErr_Occurred()) SWIG_fail;
8235 }
8236 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8237 return resultobj;
8238 fail:
8239 return NULL;
8240 }
8241
8242
8243 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8244 PyObject *resultobj = 0;
8245 wxPoint2D *arg1 = 0 ;
8246 wxPoint2D *result = 0 ;
8247 wxPoint2D temp1 ;
8248 PyObject * obj0 = 0 ;
8249 char * kwnames[] = {
8250 (char *) "pt", NULL
8251 };
8252
8253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8254 {
8255 arg1 = &temp1;
8256 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8257 }
8258 {
8259 PyThreadState* __tstate = wxPyBeginAllowThreads();
8260 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8261 wxPyEndAllowThreads(__tstate);
8262 if (PyErr_Occurred()) SWIG_fail;
8263 }
8264 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8265 return resultobj;
8266 fail:
8267 return NULL;
8268 }
8269
8270
8271 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8272 PyObject *resultobj = 0;
8273 wxPoint *arg1 = 0 ;
8274 wxPoint2D *result = 0 ;
8275 wxPoint temp1 ;
8276 PyObject * obj0 = 0 ;
8277 char * kwnames[] = {
8278 (char *) "pt", NULL
8279 };
8280
8281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8282 {
8283 arg1 = &temp1;
8284 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8285 }
8286 {
8287 PyThreadState* __tstate = wxPyBeginAllowThreads();
8288 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8289 wxPyEndAllowThreads(__tstate);
8290 if (PyErr_Occurred()) SWIG_fail;
8291 }
8292 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8293 return resultobj;
8294 fail:
8295 return NULL;
8296 }
8297
8298
8299 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8300 PyObject *resultobj = 0;
8301 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8302 int *arg2 = (int *) 0 ;
8303 int *arg3 = (int *) 0 ;
8304 void *argp1 = 0 ;
8305 int res1 = 0 ;
8306 int temp2 ;
8307 int res2 = SWIG_TMPOBJ ;
8308 int temp3 ;
8309 int res3 = SWIG_TMPOBJ ;
8310 PyObject *swig_obj[1] ;
8311
8312 arg2 = &temp2;
8313 arg3 = &temp3;
8314 if (!args) SWIG_fail;
8315 swig_obj[0] = args;
8316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8317 if (!SWIG_IsOK(res1)) {
8318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8319 }
8320 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8321 {
8322 PyThreadState* __tstate = wxPyBeginAllowThreads();
8323 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8324 wxPyEndAllowThreads(__tstate);
8325 if (PyErr_Occurred()) SWIG_fail;
8326 }
8327 resultobj = SWIG_Py_Void();
8328 if (SWIG_IsTmpObj(res2)) {
8329 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8330 } else {
8331 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8332 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8333 }
8334 if (SWIG_IsTmpObj(res3)) {
8335 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8336 } else {
8337 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8338 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8339 }
8340 return resultobj;
8341 fail:
8342 return NULL;
8343 }
8344
8345
8346 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8347 PyObject *resultobj = 0;
8348 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8349 int *arg2 = (int *) 0 ;
8350 int *arg3 = (int *) 0 ;
8351 void *argp1 = 0 ;
8352 int res1 = 0 ;
8353 int temp2 ;
8354 int res2 = SWIG_TMPOBJ ;
8355 int temp3 ;
8356 int res3 = SWIG_TMPOBJ ;
8357 PyObject *swig_obj[1] ;
8358
8359 arg2 = &temp2;
8360 arg3 = &temp3;
8361 if (!args) SWIG_fail;
8362 swig_obj[0] = args;
8363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8364 if (!SWIG_IsOK(res1)) {
8365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8366 }
8367 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8368 {
8369 PyThreadState* __tstate = wxPyBeginAllowThreads();
8370 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8371 wxPyEndAllowThreads(__tstate);
8372 if (PyErr_Occurred()) SWIG_fail;
8373 }
8374 resultobj = SWIG_Py_Void();
8375 if (SWIG_IsTmpObj(res2)) {
8376 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8377 } else {
8378 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8379 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8380 }
8381 if (SWIG_IsTmpObj(res3)) {
8382 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8383 } else {
8384 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8385 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8386 }
8387 return resultobj;
8388 fail:
8389 return NULL;
8390 }
8391
8392
8393 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8394 PyObject *resultobj = 0;
8395 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8396 double result;
8397 void *argp1 = 0 ;
8398 int res1 = 0 ;
8399 PyObject *swig_obj[1] ;
8400
8401 if (!args) SWIG_fail;
8402 swig_obj[0] = args;
8403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8404 if (!SWIG_IsOK(res1)) {
8405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8406 }
8407 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8408 {
8409 PyThreadState* __tstate = wxPyBeginAllowThreads();
8410 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8411 wxPyEndAllowThreads(__tstate);
8412 if (PyErr_Occurred()) SWIG_fail;
8413 }
8414 resultobj = SWIG_From_double(static_cast< double >(result));
8415 return resultobj;
8416 fail:
8417 return NULL;
8418 }
8419
8420
8421 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8422 PyObject *resultobj = 0;
8423 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8424 double result;
8425 void *argp1 = 0 ;
8426 int res1 = 0 ;
8427 PyObject *swig_obj[1] ;
8428
8429 if (!args) SWIG_fail;
8430 swig_obj[0] = args;
8431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8432 if (!SWIG_IsOK(res1)) {
8433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8434 }
8435 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8436 {
8437 PyThreadState* __tstate = wxPyBeginAllowThreads();
8438 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8439 wxPyEndAllowThreads(__tstate);
8440 if (PyErr_Occurred()) SWIG_fail;
8441 }
8442 resultobj = SWIG_From_double(static_cast< double >(result));
8443 return resultobj;
8444 fail:
8445 return NULL;
8446 }
8447
8448
8449 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8450 PyObject *resultobj = 0;
8451 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8452 double arg2 ;
8453 void *argp1 = 0 ;
8454 int res1 = 0 ;
8455 double val2 ;
8456 int ecode2 = 0 ;
8457 PyObject * obj0 = 0 ;
8458 PyObject * obj1 = 0 ;
8459 char * kwnames[] = {
8460 (char *) "self",(char *) "length", NULL
8461 };
8462
8463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8465 if (!SWIG_IsOK(res1)) {
8466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8467 }
8468 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8469 ecode2 = SWIG_AsVal_double(obj1, &val2);
8470 if (!SWIG_IsOK(ecode2)) {
8471 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8472 }
8473 arg2 = static_cast< double >(val2);
8474 {
8475 PyThreadState* __tstate = wxPyBeginAllowThreads();
8476 (arg1)->SetVectorLength(arg2);
8477 wxPyEndAllowThreads(__tstate);
8478 if (PyErr_Occurred()) SWIG_fail;
8479 }
8480 resultobj = SWIG_Py_Void();
8481 return resultobj;
8482 fail:
8483 return NULL;
8484 }
8485
8486
8487 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8488 PyObject *resultobj = 0;
8489 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8490 double arg2 ;
8491 void *argp1 = 0 ;
8492 int res1 = 0 ;
8493 double val2 ;
8494 int ecode2 = 0 ;
8495 PyObject * obj0 = 0 ;
8496 PyObject * obj1 = 0 ;
8497 char * kwnames[] = {
8498 (char *) "self",(char *) "degrees", NULL
8499 };
8500
8501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8503 if (!SWIG_IsOK(res1)) {
8504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8505 }
8506 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8507 ecode2 = SWIG_AsVal_double(obj1, &val2);
8508 if (!SWIG_IsOK(ecode2)) {
8509 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8510 }
8511 arg2 = static_cast< double >(val2);
8512 {
8513 PyThreadState* __tstate = wxPyBeginAllowThreads();
8514 (arg1)->SetVectorAngle(arg2);
8515 wxPyEndAllowThreads(__tstate);
8516 if (PyErr_Occurred()) SWIG_fail;
8517 }
8518 resultobj = SWIG_Py_Void();
8519 return resultobj;
8520 fail:
8521 return NULL;
8522 }
8523
8524
8525 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8526 PyObject *resultobj = 0;
8527 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8528 wxPoint2D *arg2 = 0 ;
8529 double result;
8530 void *argp1 = 0 ;
8531 int res1 = 0 ;
8532 wxPoint2D temp2 ;
8533 PyObject * obj0 = 0 ;
8534 PyObject * obj1 = 0 ;
8535 char * kwnames[] = {
8536 (char *) "self",(char *) "pt", NULL
8537 };
8538
8539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8541 if (!SWIG_IsOK(res1)) {
8542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8543 }
8544 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8545 {
8546 arg2 = &temp2;
8547 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8548 }
8549 {
8550 PyThreadState* __tstate = wxPyBeginAllowThreads();
8551 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8552 wxPyEndAllowThreads(__tstate);
8553 if (PyErr_Occurred()) SWIG_fail;
8554 }
8555 resultobj = SWIG_From_double(static_cast< double >(result));
8556 return resultobj;
8557 fail:
8558 return NULL;
8559 }
8560
8561
8562 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8563 PyObject *resultobj = 0;
8564 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8565 wxPoint2D *arg2 = 0 ;
8566 double result;
8567 void *argp1 = 0 ;
8568 int res1 = 0 ;
8569 wxPoint2D temp2 ;
8570 PyObject * obj0 = 0 ;
8571 PyObject * obj1 = 0 ;
8572 char * kwnames[] = {
8573 (char *) "self",(char *) "pt", NULL
8574 };
8575
8576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8578 if (!SWIG_IsOK(res1)) {
8579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8580 }
8581 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8582 {
8583 arg2 = &temp2;
8584 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8585 }
8586 {
8587 PyThreadState* __tstate = wxPyBeginAllowThreads();
8588 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8589 wxPyEndAllowThreads(__tstate);
8590 if (PyErr_Occurred()) SWIG_fail;
8591 }
8592 resultobj = SWIG_From_double(static_cast< double >(result));
8593 return resultobj;
8594 fail:
8595 return NULL;
8596 }
8597
8598
8599 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8600 PyObject *resultobj = 0;
8601 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8602 wxPoint2D *arg2 = 0 ;
8603 double result;
8604 void *argp1 = 0 ;
8605 int res1 = 0 ;
8606 wxPoint2D temp2 ;
8607 PyObject * obj0 = 0 ;
8608 PyObject * obj1 = 0 ;
8609 char * kwnames[] = {
8610 (char *) "self",(char *) "vec", NULL
8611 };
8612
8613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8615 if (!SWIG_IsOK(res1)) {
8616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8617 }
8618 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8619 {
8620 arg2 = &temp2;
8621 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8622 }
8623 {
8624 PyThreadState* __tstate = wxPyBeginAllowThreads();
8625 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8626 wxPyEndAllowThreads(__tstate);
8627 if (PyErr_Occurred()) SWIG_fail;
8628 }
8629 resultobj = SWIG_From_double(static_cast< double >(result));
8630 return resultobj;
8631 fail:
8632 return NULL;
8633 }
8634
8635
8636 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8637 PyObject *resultobj = 0;
8638 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8639 wxPoint2D *arg2 = 0 ;
8640 double result;
8641 void *argp1 = 0 ;
8642 int res1 = 0 ;
8643 wxPoint2D temp2 ;
8644 PyObject * obj0 = 0 ;
8645 PyObject * obj1 = 0 ;
8646 char * kwnames[] = {
8647 (char *) "self",(char *) "vec", NULL
8648 };
8649
8650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8652 if (!SWIG_IsOK(res1)) {
8653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8654 }
8655 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8656 {
8657 arg2 = &temp2;
8658 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8659 }
8660 {
8661 PyThreadState* __tstate = wxPyBeginAllowThreads();
8662 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8663 wxPyEndAllowThreads(__tstate);
8664 if (PyErr_Occurred()) SWIG_fail;
8665 }
8666 resultobj = SWIG_From_double(static_cast< double >(result));
8667 return resultobj;
8668 fail:
8669 return NULL;
8670 }
8671
8672
8673 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8674 PyObject *resultobj = 0;
8675 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8676 wxPoint2D result;
8677 void *argp1 = 0 ;
8678 int res1 = 0 ;
8679 PyObject *swig_obj[1] ;
8680
8681 if (!args) SWIG_fail;
8682 swig_obj[0] = args;
8683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8684 if (!SWIG_IsOK(res1)) {
8685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8686 }
8687 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8688 {
8689 PyThreadState* __tstate = wxPyBeginAllowThreads();
8690 result = (arg1)->operator -();
8691 wxPyEndAllowThreads(__tstate);
8692 if (PyErr_Occurred()) SWIG_fail;
8693 }
8694 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8695 return resultobj;
8696 fail:
8697 return NULL;
8698 }
8699
8700
8701 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8702 PyObject *resultobj = 0;
8703 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8704 wxPoint2D *arg2 = 0 ;
8705 wxPoint2D *result = 0 ;
8706 void *argp1 = 0 ;
8707 int res1 = 0 ;
8708 wxPoint2D temp2 ;
8709 PyObject * obj0 = 0 ;
8710 PyObject * obj1 = 0 ;
8711 char * kwnames[] = {
8712 (char *) "self",(char *) "pt", NULL
8713 };
8714
8715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8717 if (!SWIG_IsOK(res1)) {
8718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8719 }
8720 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8721 {
8722 arg2 = &temp2;
8723 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8724 }
8725 {
8726 PyThreadState* __tstate = wxPyBeginAllowThreads();
8727 {
8728 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8729 result = (wxPoint2D *) &_result_ref;
8730 }
8731 wxPyEndAllowThreads(__tstate);
8732 if (PyErr_Occurred()) SWIG_fail;
8733 }
8734 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8735 return resultobj;
8736 fail:
8737 return NULL;
8738 }
8739
8740
8741 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8742 PyObject *resultobj = 0;
8743 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8744 wxPoint2D *arg2 = 0 ;
8745 wxPoint2D *result = 0 ;
8746 void *argp1 = 0 ;
8747 int res1 = 0 ;
8748 wxPoint2D temp2 ;
8749 PyObject * obj0 = 0 ;
8750 PyObject * obj1 = 0 ;
8751 char * kwnames[] = {
8752 (char *) "self",(char *) "pt", NULL
8753 };
8754
8755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8757 if (!SWIG_IsOK(res1)) {
8758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8759 }
8760 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8761 {
8762 arg2 = &temp2;
8763 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8764 }
8765 {
8766 PyThreadState* __tstate = wxPyBeginAllowThreads();
8767 {
8768 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8769 result = (wxPoint2D *) &_result_ref;
8770 }
8771 wxPyEndAllowThreads(__tstate);
8772 if (PyErr_Occurred()) SWIG_fail;
8773 }
8774 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8775 return resultobj;
8776 fail:
8777 return NULL;
8778 }
8779
8780
8781 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8782 PyObject *resultobj = 0;
8783 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8784 wxPoint2D *arg2 = 0 ;
8785 wxPoint2D *result = 0 ;
8786 void *argp1 = 0 ;
8787 int res1 = 0 ;
8788 wxPoint2D temp2 ;
8789 PyObject * obj0 = 0 ;
8790 PyObject * obj1 = 0 ;
8791 char * kwnames[] = {
8792 (char *) "self",(char *) "pt", NULL
8793 };
8794
8795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8797 if (!SWIG_IsOK(res1)) {
8798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8799 }
8800 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8801 {
8802 arg2 = &temp2;
8803 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8804 }
8805 {
8806 PyThreadState* __tstate = wxPyBeginAllowThreads();
8807 {
8808 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8809 result = (wxPoint2D *) &_result_ref;
8810 }
8811 wxPyEndAllowThreads(__tstate);
8812 if (PyErr_Occurred()) SWIG_fail;
8813 }
8814 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8815 return resultobj;
8816 fail:
8817 return NULL;
8818 }
8819
8820
8821 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8822 PyObject *resultobj = 0;
8823 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8824 wxPoint2D *arg2 = 0 ;
8825 wxPoint2D *result = 0 ;
8826 void *argp1 = 0 ;
8827 int res1 = 0 ;
8828 wxPoint2D temp2 ;
8829 PyObject * obj0 = 0 ;
8830 PyObject * obj1 = 0 ;
8831 char * kwnames[] = {
8832 (char *) "self",(char *) "pt", NULL
8833 };
8834
8835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8837 if (!SWIG_IsOK(res1)) {
8838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8839 }
8840 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8841 {
8842 arg2 = &temp2;
8843 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8844 }
8845 {
8846 PyThreadState* __tstate = wxPyBeginAllowThreads();
8847 {
8848 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8849 result = (wxPoint2D *) &_result_ref;
8850 }
8851 wxPyEndAllowThreads(__tstate);
8852 if (PyErr_Occurred()) SWIG_fail;
8853 }
8854 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8855 return resultobj;
8856 fail:
8857 return NULL;
8858 }
8859
8860
8861 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8862 PyObject *resultobj = 0;
8863 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8864 PyObject *arg2 = (PyObject *) 0 ;
8865 bool result;
8866 void *argp1 = 0 ;
8867 int res1 = 0 ;
8868 PyObject * obj0 = 0 ;
8869 PyObject * obj1 = 0 ;
8870 char * kwnames[] = {
8871 (char *) "self",(char *) "other", NULL
8872 };
8873
8874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8876 if (!SWIG_IsOK(res1)) {
8877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8878 }
8879 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8880 arg2 = obj1;
8881 {
8882 result = (bool)wxPoint2D___eq__(arg1,arg2);
8883 if (PyErr_Occurred()) SWIG_fail;
8884 }
8885 {
8886 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8887 }
8888 return resultobj;
8889 fail:
8890 return NULL;
8891 }
8892
8893
8894 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8895 PyObject *resultobj = 0;
8896 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8897 PyObject *arg2 = (PyObject *) 0 ;
8898 bool result;
8899 void *argp1 = 0 ;
8900 int res1 = 0 ;
8901 PyObject * obj0 = 0 ;
8902 PyObject * obj1 = 0 ;
8903 char * kwnames[] = {
8904 (char *) "self",(char *) "other", NULL
8905 };
8906
8907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8909 if (!SWIG_IsOK(res1)) {
8910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8911 }
8912 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8913 arg2 = obj1;
8914 {
8915 result = (bool)wxPoint2D___ne__(arg1,arg2);
8916 if (PyErr_Occurred()) SWIG_fail;
8917 }
8918 {
8919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8920 }
8921 return resultobj;
8922 fail:
8923 return NULL;
8924 }
8925
8926
8927 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8928 PyObject *resultobj = 0;
8929 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8930 double arg2 ;
8931 void *argp1 = 0 ;
8932 int res1 = 0 ;
8933 double val2 ;
8934 int ecode2 = 0 ;
8935 PyObject *swig_obj[2] ;
8936
8937 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8939 if (!SWIG_IsOK(res1)) {
8940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8941 }
8942 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8943 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8944 if (!SWIG_IsOK(ecode2)) {
8945 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8946 }
8947 arg2 = static_cast< double >(val2);
8948 if (arg1) (arg1)->m_x = arg2;
8949
8950 resultobj = SWIG_Py_Void();
8951 return resultobj;
8952 fail:
8953 return NULL;
8954 }
8955
8956
8957 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8958 PyObject *resultobj = 0;
8959 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8960 double result;
8961 void *argp1 = 0 ;
8962 int res1 = 0 ;
8963 PyObject *swig_obj[1] ;
8964
8965 if (!args) SWIG_fail;
8966 swig_obj[0] = args;
8967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8968 if (!SWIG_IsOK(res1)) {
8969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8970 }
8971 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8972 result = (double) ((arg1)->m_x);
8973 resultobj = SWIG_From_double(static_cast< double >(result));
8974 return resultobj;
8975 fail:
8976 return NULL;
8977 }
8978
8979
8980 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8981 PyObject *resultobj = 0;
8982 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8983 double arg2 ;
8984 void *argp1 = 0 ;
8985 int res1 = 0 ;
8986 double val2 ;
8987 int ecode2 = 0 ;
8988 PyObject *swig_obj[2] ;
8989
8990 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8992 if (!SWIG_IsOK(res1)) {
8993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8994 }
8995 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8996 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8997 if (!SWIG_IsOK(ecode2)) {
8998 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8999 }
9000 arg2 = static_cast< double >(val2);
9001 if (arg1) (arg1)->m_y = arg2;
9002
9003 resultobj = SWIG_Py_Void();
9004 return resultobj;
9005 fail:
9006 return NULL;
9007 }
9008
9009
9010 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9011 PyObject *resultobj = 0;
9012 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9013 double result;
9014 void *argp1 = 0 ;
9015 int res1 = 0 ;
9016 PyObject *swig_obj[1] ;
9017
9018 if (!args) SWIG_fail;
9019 swig_obj[0] = args;
9020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9021 if (!SWIG_IsOK(res1)) {
9022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9023 }
9024 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9025 result = (double) ((arg1)->m_y);
9026 resultobj = SWIG_From_double(static_cast< double >(result));
9027 return resultobj;
9028 fail:
9029 return NULL;
9030 }
9031
9032
9033 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9034 PyObject *resultobj = 0;
9035 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9036 double arg2 = (double) 0 ;
9037 double arg3 = (double) 0 ;
9038 void *argp1 = 0 ;
9039 int res1 = 0 ;
9040 double val2 ;
9041 int ecode2 = 0 ;
9042 double val3 ;
9043 int ecode3 = 0 ;
9044 PyObject * obj0 = 0 ;
9045 PyObject * obj1 = 0 ;
9046 PyObject * obj2 = 0 ;
9047 char * kwnames[] = {
9048 (char *) "self",(char *) "x",(char *) "y", NULL
9049 };
9050
9051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9053 if (!SWIG_IsOK(res1)) {
9054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9055 }
9056 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9057 if (obj1) {
9058 ecode2 = SWIG_AsVal_double(obj1, &val2);
9059 if (!SWIG_IsOK(ecode2)) {
9060 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
9061 }
9062 arg2 = static_cast< double >(val2);
9063 }
9064 if (obj2) {
9065 ecode3 = SWIG_AsVal_double(obj2, &val3);
9066 if (!SWIG_IsOK(ecode3)) {
9067 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
9068 }
9069 arg3 = static_cast< double >(val3);
9070 }
9071 {
9072 PyThreadState* __tstate = wxPyBeginAllowThreads();
9073 wxPoint2D_Set(arg1,arg2,arg3);
9074 wxPyEndAllowThreads(__tstate);
9075 if (PyErr_Occurred()) SWIG_fail;
9076 }
9077 resultobj = SWIG_Py_Void();
9078 return resultobj;
9079 fail:
9080 return NULL;
9081 }
9082
9083
9084 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9085 PyObject *resultobj = 0;
9086 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9087 PyObject *result = 0 ;
9088 void *argp1 = 0 ;
9089 int res1 = 0 ;
9090 PyObject *swig_obj[1] ;
9091
9092 if (!args) SWIG_fail;
9093 swig_obj[0] = args;
9094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9095 if (!SWIG_IsOK(res1)) {
9096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9097 }
9098 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9099 {
9100 PyThreadState* __tstate = wxPyBeginAllowThreads();
9101 result = (PyObject *)wxPoint2D_Get(arg1);
9102 wxPyEndAllowThreads(__tstate);
9103 if (PyErr_Occurred()) SWIG_fail;
9104 }
9105 resultobj = result;
9106 return resultobj;
9107 fail:
9108 return NULL;
9109 }
9110
9111
9112 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9113 PyObject *obj;
9114 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9115 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
9116 return SWIG_Py_Void();
9117 }
9118
9119 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9120 return SWIG_Python_InitShadowInstance(args);
9121 }
9122
9123 SWIGINTERN int DefaultPosition_set(PyObject *) {
9124 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
9125 return 1;
9126 }
9127
9128
9129 SWIGINTERN PyObject *DefaultPosition_get(void) {
9130 PyObject *pyobj = 0;
9131
9132 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
9133 return pyobj;
9134 }
9135
9136
9137 SWIGINTERN int DefaultSize_set(PyObject *) {
9138 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
9139 return 1;
9140 }
9141
9142
9143 SWIGINTERN PyObject *DefaultSize_get(void) {
9144 PyObject *pyobj = 0;
9145
9146 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
9147 return pyobj;
9148 }
9149
9150
9151 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9152 PyObject *resultobj = 0;
9153 PyObject *arg1 = (PyObject *) 0 ;
9154 wxPyInputStream *result = 0 ;
9155 PyObject * obj0 = 0 ;
9156 char * kwnames[] = {
9157 (char *) "p", NULL
9158 };
9159
9160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
9161 arg1 = obj0;
9162 {
9163 PyThreadState* __tstate = wxPyBeginAllowThreads();
9164 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
9165 wxPyEndAllowThreads(__tstate);
9166 if (PyErr_Occurred()) SWIG_fail;
9167 }
9168 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
9169 return resultobj;
9170 fail:
9171 return NULL;
9172 }
9173
9174
9175 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9176 PyObject *resultobj = 0;
9177 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9178 void *argp1 = 0 ;
9179 int res1 = 0 ;
9180 PyObject *swig_obj[1] ;
9181
9182 if (!args) SWIG_fail;
9183 swig_obj[0] = args;
9184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
9185 if (!SWIG_IsOK(res1)) {
9186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9187 }
9188 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9189 {
9190 PyThreadState* __tstate = wxPyBeginAllowThreads();
9191 delete arg1;
9192
9193 wxPyEndAllowThreads(__tstate);
9194 if (PyErr_Occurred()) SWIG_fail;
9195 }
9196 resultobj = SWIG_Py_Void();
9197 return resultobj;
9198 fail:
9199 return NULL;
9200 }
9201
9202
9203 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9204 PyObject *resultobj = 0;
9205 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9206 void *argp1 = 0 ;
9207 int res1 = 0 ;
9208 PyObject *swig_obj[1] ;
9209
9210 if (!args) SWIG_fail;
9211 swig_obj[0] = args;
9212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9213 if (!SWIG_IsOK(res1)) {
9214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9215 }
9216 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9217 {
9218 PyThreadState* __tstate = wxPyBeginAllowThreads();
9219 (arg1)->close();
9220 wxPyEndAllowThreads(__tstate);
9221 if (PyErr_Occurred()) SWIG_fail;
9222 }
9223 resultobj = SWIG_Py_Void();
9224 return resultobj;
9225 fail:
9226 return NULL;
9227 }
9228
9229
9230 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9231 PyObject *resultobj = 0;
9232 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9233 void *argp1 = 0 ;
9234 int res1 = 0 ;
9235 PyObject *swig_obj[1] ;
9236
9237 if (!args) SWIG_fail;
9238 swig_obj[0] = args;
9239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9240 if (!SWIG_IsOK(res1)) {
9241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9242 }
9243 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9244 {
9245 PyThreadState* __tstate = wxPyBeginAllowThreads();
9246 (arg1)->flush();
9247 wxPyEndAllowThreads(__tstate);
9248 if (PyErr_Occurred()) SWIG_fail;
9249 }
9250 resultobj = SWIG_Py_Void();
9251 return resultobj;
9252 fail:
9253 return NULL;
9254 }
9255
9256
9257 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9258 PyObject *resultobj = 0;
9259 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9260 bool result;
9261 void *argp1 = 0 ;
9262 int res1 = 0 ;
9263 PyObject *swig_obj[1] ;
9264
9265 if (!args) SWIG_fail;
9266 swig_obj[0] = args;
9267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9268 if (!SWIG_IsOK(res1)) {
9269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9270 }
9271 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9272 {
9273 PyThreadState* __tstate = wxPyBeginAllowThreads();
9274 result = (bool)(arg1)->eof();
9275 wxPyEndAllowThreads(__tstate);
9276 if (PyErr_Occurred()) SWIG_fail;
9277 }
9278 {
9279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9280 }
9281 return resultobj;
9282 fail:
9283 return NULL;
9284 }
9285
9286
9287 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9288 PyObject *resultobj = 0;
9289 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9290 int arg2 = (int) -1 ;
9291 PyObject *result = 0 ;
9292 void *argp1 = 0 ;
9293 int res1 = 0 ;
9294 int val2 ;
9295 int ecode2 = 0 ;
9296 PyObject * obj0 = 0 ;
9297 PyObject * obj1 = 0 ;
9298 char * kwnames[] = {
9299 (char *) "self",(char *) "size", NULL
9300 };
9301
9302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9304 if (!SWIG_IsOK(res1)) {
9305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9306 }
9307 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9308 if (obj1) {
9309 ecode2 = SWIG_AsVal_int(obj1, &val2);
9310 if (!SWIG_IsOK(ecode2)) {
9311 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9312 }
9313 arg2 = static_cast< int >(val2);
9314 }
9315 {
9316 PyThreadState* __tstate = wxPyBeginAllowThreads();
9317 result = (PyObject *)(arg1)->read(arg2);
9318 wxPyEndAllowThreads(__tstate);
9319 if (PyErr_Occurred()) SWIG_fail;
9320 }
9321 resultobj = result;
9322 return resultobj;
9323 fail:
9324 return NULL;
9325 }
9326
9327
9328 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9329 PyObject *resultobj = 0;
9330 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9331 int arg2 = (int) -1 ;
9332 PyObject *result = 0 ;
9333 void *argp1 = 0 ;
9334 int res1 = 0 ;
9335 int val2 ;
9336 int ecode2 = 0 ;
9337 PyObject * obj0 = 0 ;
9338 PyObject * obj1 = 0 ;
9339 char * kwnames[] = {
9340 (char *) "self",(char *) "size", NULL
9341 };
9342
9343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9345 if (!SWIG_IsOK(res1)) {
9346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9347 }
9348 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9349 if (obj1) {
9350 ecode2 = SWIG_AsVal_int(obj1, &val2);
9351 if (!SWIG_IsOK(ecode2)) {
9352 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9353 }
9354 arg2 = static_cast< int >(val2);
9355 }
9356 {
9357 PyThreadState* __tstate = wxPyBeginAllowThreads();
9358 result = (PyObject *)(arg1)->readline(arg2);
9359 wxPyEndAllowThreads(__tstate);
9360 if (PyErr_Occurred()) SWIG_fail;
9361 }
9362 resultobj = result;
9363 return resultobj;
9364 fail:
9365 return NULL;
9366 }
9367
9368
9369 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9370 PyObject *resultobj = 0;
9371 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9372 int arg2 = (int) -1 ;
9373 PyObject *result = 0 ;
9374 void *argp1 = 0 ;
9375 int res1 = 0 ;
9376 int val2 ;
9377 int ecode2 = 0 ;
9378 PyObject * obj0 = 0 ;
9379 PyObject * obj1 = 0 ;
9380 char * kwnames[] = {
9381 (char *) "self",(char *) "sizehint", NULL
9382 };
9383
9384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9386 if (!SWIG_IsOK(res1)) {
9387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9388 }
9389 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9390 if (obj1) {
9391 ecode2 = SWIG_AsVal_int(obj1, &val2);
9392 if (!SWIG_IsOK(ecode2)) {
9393 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9394 }
9395 arg2 = static_cast< int >(val2);
9396 }
9397 {
9398 PyThreadState* __tstate = wxPyBeginAllowThreads();
9399 result = (PyObject *)(arg1)->readlines(arg2);
9400 wxPyEndAllowThreads(__tstate);
9401 if (PyErr_Occurred()) SWIG_fail;
9402 }
9403 resultobj = result;
9404 return resultobj;
9405 fail:
9406 return NULL;
9407 }
9408
9409
9410 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9411 PyObject *resultobj = 0;
9412 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9413 int arg2 ;
9414 int arg3 = (int) 0 ;
9415 void *argp1 = 0 ;
9416 int res1 = 0 ;
9417 int val2 ;
9418 int ecode2 = 0 ;
9419 int val3 ;
9420 int ecode3 = 0 ;
9421 PyObject * obj0 = 0 ;
9422 PyObject * obj1 = 0 ;
9423 PyObject * obj2 = 0 ;
9424 char * kwnames[] = {
9425 (char *) "self",(char *) "offset",(char *) "whence", NULL
9426 };
9427
9428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9430 if (!SWIG_IsOK(res1)) {
9431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9432 }
9433 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9434 ecode2 = SWIG_AsVal_int(obj1, &val2);
9435 if (!SWIG_IsOK(ecode2)) {
9436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9437 }
9438 arg2 = static_cast< int >(val2);
9439 if (obj2) {
9440 ecode3 = SWIG_AsVal_int(obj2, &val3);
9441 if (!SWIG_IsOK(ecode3)) {
9442 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9443 }
9444 arg3 = static_cast< int >(val3);
9445 }
9446 {
9447 PyThreadState* __tstate = wxPyBeginAllowThreads();
9448 (arg1)->seek(arg2,arg3);
9449 wxPyEndAllowThreads(__tstate);
9450 if (PyErr_Occurred()) SWIG_fail;
9451 }
9452 resultobj = SWIG_Py_Void();
9453 return resultobj;
9454 fail:
9455 return NULL;
9456 }
9457
9458
9459 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9460 PyObject *resultobj = 0;
9461 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9462 int result;
9463 void *argp1 = 0 ;
9464 int res1 = 0 ;
9465 PyObject *swig_obj[1] ;
9466
9467 if (!args) SWIG_fail;
9468 swig_obj[0] = args;
9469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9470 if (!SWIG_IsOK(res1)) {
9471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9472 }
9473 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9474 {
9475 PyThreadState* __tstate = wxPyBeginAllowThreads();
9476 result = (int)(arg1)->tell();
9477 wxPyEndAllowThreads(__tstate);
9478 if (PyErr_Occurred()) SWIG_fail;
9479 }
9480 resultobj = SWIG_From_int(static_cast< int >(result));
9481 return resultobj;
9482 fail:
9483 return NULL;
9484 }
9485
9486
9487 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9488 PyObject *resultobj = 0;
9489 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9490 char result;
9491 void *argp1 = 0 ;
9492 int res1 = 0 ;
9493 PyObject *swig_obj[1] ;
9494
9495 if (!args) SWIG_fail;
9496 swig_obj[0] = args;
9497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9498 if (!SWIG_IsOK(res1)) {
9499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9500 }
9501 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9502 {
9503 PyThreadState* __tstate = wxPyBeginAllowThreads();
9504 result = (char)(arg1)->Peek();
9505 wxPyEndAllowThreads(__tstate);
9506 if (PyErr_Occurred()) SWIG_fail;
9507 }
9508 resultobj = SWIG_From_char(static_cast< char >(result));
9509 return resultobj;
9510 fail:
9511 return NULL;
9512 }
9513
9514
9515 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9516 PyObject *resultobj = 0;
9517 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9518 char result;
9519 void *argp1 = 0 ;
9520 int res1 = 0 ;
9521 PyObject *swig_obj[1] ;
9522
9523 if (!args) SWIG_fail;
9524 swig_obj[0] = args;
9525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9526 if (!SWIG_IsOK(res1)) {
9527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9528 }
9529 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9530 {
9531 PyThreadState* __tstate = wxPyBeginAllowThreads();
9532 result = (char)(arg1)->GetC();
9533 wxPyEndAllowThreads(__tstate);
9534 if (PyErr_Occurred()) SWIG_fail;
9535 }
9536 resultobj = SWIG_From_char(static_cast< char >(result));
9537 return resultobj;
9538 fail:
9539 return NULL;
9540 }
9541
9542
9543 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9544 PyObject *resultobj = 0;
9545 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9546 size_t result;
9547 void *argp1 = 0 ;
9548 int res1 = 0 ;
9549 PyObject *swig_obj[1] ;
9550
9551 if (!args) SWIG_fail;
9552 swig_obj[0] = args;
9553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9554 if (!SWIG_IsOK(res1)) {
9555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9556 }
9557 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9558 {
9559 PyThreadState* __tstate = wxPyBeginAllowThreads();
9560 result = (size_t)(arg1)->LastRead();
9561 wxPyEndAllowThreads(__tstate);
9562 if (PyErr_Occurred()) SWIG_fail;
9563 }
9564 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9565 return resultobj;
9566 fail:
9567 return NULL;
9568 }
9569
9570
9571 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9572 PyObject *resultobj = 0;
9573 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9574 bool result;
9575 void *argp1 = 0 ;
9576 int res1 = 0 ;
9577 PyObject *swig_obj[1] ;
9578
9579 if (!args) SWIG_fail;
9580 swig_obj[0] = args;
9581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9582 if (!SWIG_IsOK(res1)) {
9583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9584 }
9585 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9586 {
9587 PyThreadState* __tstate = wxPyBeginAllowThreads();
9588 result = (bool)(arg1)->CanRead();
9589 wxPyEndAllowThreads(__tstate);
9590 if (PyErr_Occurred()) SWIG_fail;
9591 }
9592 {
9593 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9594 }
9595 return resultobj;
9596 fail:
9597 return NULL;
9598 }
9599
9600
9601 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9602 PyObject *resultobj = 0;
9603 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9604 bool result;
9605 void *argp1 = 0 ;
9606 int res1 = 0 ;
9607 PyObject *swig_obj[1] ;
9608
9609 if (!args) SWIG_fail;
9610 swig_obj[0] = args;
9611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9612 if (!SWIG_IsOK(res1)) {
9613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9614 }
9615 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9616 {
9617 PyThreadState* __tstate = wxPyBeginAllowThreads();
9618 result = (bool)(arg1)->Eof();
9619 wxPyEndAllowThreads(__tstate);
9620 if (PyErr_Occurred()) SWIG_fail;
9621 }
9622 {
9623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9624 }
9625 return resultobj;
9626 fail:
9627 return NULL;
9628 }
9629
9630
9631 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9632 PyObject *resultobj = 0;
9633 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9634 char arg2 ;
9635 bool result;
9636 void *argp1 = 0 ;
9637 int res1 = 0 ;
9638 char val2 ;
9639 int ecode2 = 0 ;
9640 PyObject * obj0 = 0 ;
9641 PyObject * obj1 = 0 ;
9642 char * kwnames[] = {
9643 (char *) "self",(char *) "c", NULL
9644 };
9645
9646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9648 if (!SWIG_IsOK(res1)) {
9649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9650 }
9651 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9652 ecode2 = SWIG_AsVal_char(obj1, &val2);
9653 if (!SWIG_IsOK(ecode2)) {
9654 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9655 }
9656 arg2 = static_cast< char >(val2);
9657 {
9658 PyThreadState* __tstate = wxPyBeginAllowThreads();
9659 result = (bool)(arg1)->Ungetch(arg2);
9660 wxPyEndAllowThreads(__tstate);
9661 if (PyErr_Occurred()) SWIG_fail;
9662 }
9663 {
9664 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9665 }
9666 return resultobj;
9667 fail:
9668 return NULL;
9669 }
9670
9671
9672 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9673 PyObject *resultobj = 0;
9674 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9675 long arg2 ;
9676 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9677 long result;
9678 void *argp1 = 0 ;
9679 int res1 = 0 ;
9680 long val2 ;
9681 int ecode2 = 0 ;
9682 int val3 ;
9683 int ecode3 = 0 ;
9684 PyObject * obj0 = 0 ;
9685 PyObject * obj1 = 0 ;
9686 PyObject * obj2 = 0 ;
9687 char * kwnames[] = {
9688 (char *) "self",(char *) "pos",(char *) "mode", NULL
9689 };
9690
9691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9693 if (!SWIG_IsOK(res1)) {
9694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9695 }
9696 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9697 ecode2 = SWIG_AsVal_long(obj1, &val2);
9698 if (!SWIG_IsOK(ecode2)) {
9699 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9700 }
9701 arg2 = static_cast< long >(val2);
9702 if (obj2) {
9703 ecode3 = SWIG_AsVal_int(obj2, &val3);
9704 if (!SWIG_IsOK(ecode3)) {
9705 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9706 }
9707 arg3 = static_cast< wxSeekMode >(val3);
9708 }
9709 {
9710 PyThreadState* __tstate = wxPyBeginAllowThreads();
9711 result = (long)(arg1)->SeekI(arg2,arg3);
9712 wxPyEndAllowThreads(__tstate);
9713 if (PyErr_Occurred()) SWIG_fail;
9714 }
9715 resultobj = SWIG_From_long(static_cast< long >(result));
9716 return resultobj;
9717 fail:
9718 return NULL;
9719 }
9720
9721
9722 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9723 PyObject *resultobj = 0;
9724 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9725 long result;
9726 void *argp1 = 0 ;
9727 int res1 = 0 ;
9728 PyObject *swig_obj[1] ;
9729
9730 if (!args) SWIG_fail;
9731 swig_obj[0] = args;
9732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9733 if (!SWIG_IsOK(res1)) {
9734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9735 }
9736 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9737 {
9738 PyThreadState* __tstate = wxPyBeginAllowThreads();
9739 result = (long)(arg1)->TellI();
9740 wxPyEndAllowThreads(__tstate);
9741 if (PyErr_Occurred()) SWIG_fail;
9742 }
9743 resultobj = SWIG_From_long(static_cast< long >(result));
9744 return resultobj;
9745 fail:
9746 return NULL;
9747 }
9748
9749
9750 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9751 PyObject *obj;
9752 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9753 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9754 return SWIG_Py_Void();
9755 }
9756
9757 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9758 return SWIG_Python_InitShadowInstance(args);
9759 }
9760
9761 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9762 PyObject *resultobj = 0;
9763 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9764 PyObject *arg2 = (PyObject *) 0 ;
9765 void *argp1 = 0 ;
9766 int res1 = 0 ;
9767 PyObject * obj0 = 0 ;
9768 PyObject * obj1 = 0 ;
9769 char * kwnames[] = {
9770 (char *) "self",(char *) "obj", NULL
9771 };
9772
9773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9775 if (!SWIG_IsOK(res1)) {
9776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9777 }
9778 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9779 arg2 = obj1;
9780 {
9781 PyThreadState* __tstate = wxPyBeginAllowThreads();
9782 wxOutputStream_write(arg1,arg2);
9783 wxPyEndAllowThreads(__tstate);
9784 if (PyErr_Occurred()) SWIG_fail;
9785 }
9786 resultobj = SWIG_Py_Void();
9787 return resultobj;
9788 fail:
9789 return NULL;
9790 }
9791
9792
9793 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9794 PyObject *resultobj = 0;
9795 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9796 size_t result;
9797 void *argp1 = 0 ;
9798 int res1 = 0 ;
9799 PyObject *swig_obj[1] ;
9800
9801 if (!args) SWIG_fail;
9802 swig_obj[0] = args;
9803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9804 if (!SWIG_IsOK(res1)) {
9805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9806 }
9807 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9808 {
9809 PyThreadState* __tstate = wxPyBeginAllowThreads();
9810 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9811 wxPyEndAllowThreads(__tstate);
9812 if (PyErr_Occurred()) SWIG_fail;
9813 }
9814 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9815 return resultobj;
9816 fail:
9817 return NULL;
9818 }
9819
9820
9821 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9822 PyObject *obj;
9823 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9824 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9825 return SWIG_Py_Void();
9826 }
9827
9828 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9829 PyObject *resultobj = 0;
9830 wxInputStream *arg1 = (wxInputStream *) 0 ;
9831 wxString *arg2 = 0 ;
9832 wxString *arg3 = 0 ;
9833 wxString *arg4 = 0 ;
9834 wxDateTime arg5 ;
9835 wxFSFile *result = 0 ;
9836 wxPyInputStream *temp1 ;
9837 bool temp2 = false ;
9838 bool temp3 = false ;
9839 bool temp4 = false ;
9840 void *argp5 ;
9841 int res5 = 0 ;
9842 PyObject * obj0 = 0 ;
9843 PyObject * obj1 = 0 ;
9844 PyObject * obj2 = 0 ;
9845 PyObject * obj3 = 0 ;
9846 PyObject * obj4 = 0 ;
9847 char * kwnames[] = {
9848 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9849 };
9850
9851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9852 {
9853 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9854 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9855 } else {
9856 PyErr_Clear(); // clear the failure of the wxPyConvert above
9857 arg1 = wxPyCBInputStream_create(obj0, true);
9858 if (arg1 == NULL) {
9859 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9860 SWIG_fail;
9861 }
9862 }
9863 }
9864 {
9865 arg2 = wxString_in_helper(obj1);
9866 if (arg2 == NULL) SWIG_fail;
9867 temp2 = true;
9868 }
9869 {
9870 arg3 = wxString_in_helper(obj2);
9871 if (arg3 == NULL) SWIG_fail;
9872 temp3 = true;
9873 }
9874 {
9875 arg4 = wxString_in_helper(obj3);
9876 if (arg4 == NULL) SWIG_fail;
9877 temp4 = true;
9878 }
9879 {
9880 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9881 if (!SWIG_IsOK(res5)) {
9882 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9883 }
9884 if (!argp5) {
9885 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9886 } else {
9887 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9888 arg5 = *temp;
9889 if (SWIG_IsNewObj(res5)) delete temp;
9890 }
9891 }
9892 {
9893 PyThreadState* __tstate = wxPyBeginAllowThreads();
9894 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9895 wxPyEndAllowThreads(__tstate);
9896 if (PyErr_Occurred()) SWIG_fail;
9897 }
9898 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
9899 {
9900 if (temp2)
9901 delete arg2;
9902 }
9903 {
9904 if (temp3)
9905 delete arg3;
9906 }
9907 {
9908 if (temp4)
9909 delete arg4;
9910 }
9911 return resultobj;
9912 fail:
9913 {
9914 if (temp2)
9915 delete arg2;
9916 }
9917 {
9918 if (temp3)
9919 delete arg3;
9920 }
9921 {
9922 if (temp4)
9923 delete arg4;
9924 }
9925 return NULL;
9926 }
9927
9928
9929 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9930 PyObject *resultobj = 0;
9931 wxFSFile *arg1 = (wxFSFile *) 0 ;
9932 void *argp1 = 0 ;
9933 int res1 = 0 ;
9934 PyObject *swig_obj[1] ;
9935
9936 if (!args) SWIG_fail;
9937 swig_obj[0] = args;
9938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
9939 if (!SWIG_IsOK(res1)) {
9940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
9941 }
9942 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9943 {
9944 PyThreadState* __tstate = wxPyBeginAllowThreads();
9945 delete arg1;
9946
9947 wxPyEndAllowThreads(__tstate);
9948 if (PyErr_Occurred()) SWIG_fail;
9949 }
9950 resultobj = SWIG_Py_Void();
9951 return resultobj;
9952 fail:
9953 return NULL;
9954 }
9955
9956
9957 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9958 PyObject *resultobj = 0;
9959 wxFSFile *arg1 = (wxFSFile *) 0 ;
9960 wxInputStream *result = 0 ;
9961 void *argp1 = 0 ;
9962 int res1 = 0 ;
9963 PyObject *swig_obj[1] ;
9964
9965 if (!args) SWIG_fail;
9966 swig_obj[0] = args;
9967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9968 if (!SWIG_IsOK(res1)) {
9969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9970 }
9971 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9972 {
9973 PyThreadState* __tstate = wxPyBeginAllowThreads();
9974 result = (wxInputStream *)(arg1)->GetStream();
9975 wxPyEndAllowThreads(__tstate);
9976 if (PyErr_Occurred()) SWIG_fail;
9977 }
9978 {
9979 wxPyInputStream * _ptr = NULL;
9980
9981 if (result) {
9982 _ptr = new wxPyInputStream(result);
9983 }
9984 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
9985 }
9986 return resultobj;
9987 fail:
9988 return NULL;
9989 }
9990
9991
9992 SWIGINTERN PyObject *_wrap_FSFile_DetachStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9993 PyObject *resultobj = 0;
9994 wxFSFile *arg1 = (wxFSFile *) 0 ;
9995 void *argp1 = 0 ;
9996 int res1 = 0 ;
9997 PyObject *swig_obj[1] ;
9998
9999 if (!args) SWIG_fail;
10000 swig_obj[0] = args;
10001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10002 if (!SWIG_IsOK(res1)) {
10003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_DetachStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
10004 }
10005 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10006 {
10007 PyThreadState* __tstate = wxPyBeginAllowThreads();
10008 (arg1)->DetachStream();
10009 wxPyEndAllowThreads(__tstate);
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_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10020 PyObject *resultobj = 0;
10021 wxFSFile *arg1 = (wxFSFile *) 0 ;
10022 wxString *result = 0 ;
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_wxFSFile, 0 | 0 );
10030 if (!SWIG_IsOK(res1)) {
10031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
10032 }
10033 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10034 {
10035 PyThreadState* __tstate = wxPyBeginAllowThreads();
10036 {
10037 wxString const &_result_ref = (arg1)->GetMimeType();
10038 result = (wxString *) &_result_ref;
10039 }
10040 wxPyEndAllowThreads(__tstate);
10041 if (PyErr_Occurred()) SWIG_fail;
10042 }
10043 {
10044 #if wxUSE_UNICODE
10045 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10046 #else
10047 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10048 #endif
10049 }
10050 return resultobj;
10051 fail:
10052 return NULL;
10053 }
10054
10055
10056 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10057 PyObject *resultobj = 0;
10058 wxFSFile *arg1 = (wxFSFile *) 0 ;
10059 wxString *result = 0 ;
10060 void *argp1 = 0 ;
10061 int res1 = 0 ;
10062 PyObject *swig_obj[1] ;
10063
10064 if (!args) SWIG_fail;
10065 swig_obj[0] = args;
10066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10067 if (!SWIG_IsOK(res1)) {
10068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
10069 }
10070 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10071 {
10072 PyThreadState* __tstate = wxPyBeginAllowThreads();
10073 {
10074 wxString const &_result_ref = (arg1)->GetLocation();
10075 result = (wxString *) &_result_ref;
10076 }
10077 wxPyEndAllowThreads(__tstate);
10078 if (PyErr_Occurred()) SWIG_fail;
10079 }
10080 {
10081 #if wxUSE_UNICODE
10082 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10083 #else
10084 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10085 #endif
10086 }
10087 return resultobj;
10088 fail:
10089 return NULL;
10090 }
10091
10092
10093 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10094 PyObject *resultobj = 0;
10095 wxFSFile *arg1 = (wxFSFile *) 0 ;
10096 wxString *result = 0 ;
10097 void *argp1 = 0 ;
10098 int res1 = 0 ;
10099 PyObject *swig_obj[1] ;
10100
10101 if (!args) SWIG_fail;
10102 swig_obj[0] = args;
10103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10104 if (!SWIG_IsOK(res1)) {
10105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
10106 }
10107 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10108 {
10109 PyThreadState* __tstate = wxPyBeginAllowThreads();
10110 {
10111 wxString const &_result_ref = (arg1)->GetAnchor();
10112 result = (wxString *) &_result_ref;
10113 }
10114 wxPyEndAllowThreads(__tstate);
10115 if (PyErr_Occurred()) SWIG_fail;
10116 }
10117 {
10118 #if wxUSE_UNICODE
10119 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
10120 #else
10121 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
10122 #endif
10123 }
10124 return resultobj;
10125 fail:
10126 return NULL;
10127 }
10128
10129
10130 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10131 PyObject *resultobj = 0;
10132 wxFSFile *arg1 = (wxFSFile *) 0 ;
10133 wxDateTime result;
10134 void *argp1 = 0 ;
10135 int res1 = 0 ;
10136 PyObject *swig_obj[1] ;
10137
10138 if (!args) SWIG_fail;
10139 swig_obj[0] = args;
10140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10141 if (!SWIG_IsOK(res1)) {
10142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
10143 }
10144 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10145 {
10146 PyThreadState* __tstate = wxPyBeginAllowThreads();
10147 result = (arg1)->GetModificationTime();
10148 wxPyEndAllowThreads(__tstate);
10149 if (PyErr_Occurred()) SWIG_fail;
10150 }
10151 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
10152 return resultobj;
10153 fail:
10154 return NULL;
10155 }
10156
10157
10158 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10159 PyObject *obj;
10160 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10161 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
10162 return SWIG_Py_Void();
10163 }
10164
10165 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10166 return SWIG_Python_InitShadowInstance(args);
10167 }
10168
10169 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10170 PyObject *resultobj = 0;
10171 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10172 void *argp1 = 0 ;
10173 int res1 = 0 ;
10174 PyObject *swig_obj[1] ;
10175
10176 if (!args) SWIG_fail;
10177 swig_obj[0] = args;
10178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10179 if (!SWIG_IsOK(res1)) {
10180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10181 }
10182 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
10183 {
10184 PyThreadState* __tstate = wxPyBeginAllowThreads();
10185 delete arg1;
10186
10187 wxPyEndAllowThreads(__tstate);
10188 if (PyErr_Occurred()) SWIG_fail;
10189 }
10190 resultobj = SWIG_Py_Void();
10191 return resultobj;
10192 fail:
10193 return NULL;
10194 }
10195
10196
10197 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10198 PyObject *obj;
10199 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10200 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
10201 return SWIG_Py_Void();
10202 }
10203
10204 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10205 PyObject *resultobj = 0;
10206 wxPyFileSystemHandler *result = 0 ;
10207
10208 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
10209 {
10210 PyThreadState* __tstate = wxPyBeginAllowThreads();
10211 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
10212 wxPyEndAllowThreads(__tstate);
10213 if (PyErr_Occurred()) SWIG_fail;
10214 }
10215 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
10216 return resultobj;
10217 fail:
10218 return NULL;
10219 }
10220
10221
10222 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10223 PyObject *resultobj = 0;
10224 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10225 PyObject *arg2 = (PyObject *) 0 ;
10226 PyObject *arg3 = (PyObject *) 0 ;
10227 void *argp1 = 0 ;
10228 int res1 = 0 ;
10229 PyObject * obj0 = 0 ;
10230 PyObject * obj1 = 0 ;
10231 PyObject * obj2 = 0 ;
10232 char * kwnames[] = {
10233 (char *) "self",(char *) "self",(char *) "_class", NULL
10234 };
10235
10236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10238 if (!SWIG_IsOK(res1)) {
10239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10240 }
10241 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10242 arg2 = obj1;
10243 arg3 = obj2;
10244 {
10245 PyThreadState* __tstate = wxPyBeginAllowThreads();
10246 (arg1)->_setCallbackInfo(arg2,arg3);
10247 wxPyEndAllowThreads(__tstate);
10248 if (PyErr_Occurred()) SWIG_fail;
10249 }
10250 resultobj = SWIG_Py_Void();
10251 return resultobj;
10252 fail:
10253 return NULL;
10254 }
10255
10256
10257 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10258 PyObject *resultobj = 0;
10259 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10260 wxString *arg2 = 0 ;
10261 bool result;
10262 void *argp1 = 0 ;
10263 int res1 = 0 ;
10264 bool temp2 = false ;
10265 PyObject * obj0 = 0 ;
10266 PyObject * obj1 = 0 ;
10267 char * kwnames[] = {
10268 (char *) "self",(char *) "location", NULL
10269 };
10270
10271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10273 if (!SWIG_IsOK(res1)) {
10274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10275 }
10276 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10277 {
10278 arg2 = wxString_in_helper(obj1);
10279 if (arg2 == NULL) SWIG_fail;
10280 temp2 = true;
10281 }
10282 {
10283 PyThreadState* __tstate = wxPyBeginAllowThreads();
10284 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10285 wxPyEndAllowThreads(__tstate);
10286 if (PyErr_Occurred()) SWIG_fail;
10287 }
10288 {
10289 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10290 }
10291 {
10292 if (temp2)
10293 delete arg2;
10294 }
10295 return resultobj;
10296 fail:
10297 {
10298 if (temp2)
10299 delete arg2;
10300 }
10301 return NULL;
10302 }
10303
10304
10305 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10306 PyObject *resultobj = 0;
10307 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10308 wxFileSystem *arg2 = 0 ;
10309 wxString *arg3 = 0 ;
10310 wxFSFile *result = 0 ;
10311 void *argp1 = 0 ;
10312 int res1 = 0 ;
10313 void *argp2 = 0 ;
10314 int res2 = 0 ;
10315 bool temp3 = false ;
10316 PyObject * obj0 = 0 ;
10317 PyObject * obj1 = 0 ;
10318 PyObject * obj2 = 0 ;
10319 char * kwnames[] = {
10320 (char *) "self",(char *) "fs",(char *) "location", NULL
10321 };
10322
10323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10324 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10325 if (!SWIG_IsOK(res1)) {
10326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10327 }
10328 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10329 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10330 if (!SWIG_IsOK(res2)) {
10331 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10332 }
10333 if (!argp2) {
10334 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10335 }
10336 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10337 {
10338 arg3 = wxString_in_helper(obj2);
10339 if (arg3 == NULL) SWIG_fail;
10340 temp3 = true;
10341 }
10342 {
10343 PyThreadState* __tstate = wxPyBeginAllowThreads();
10344 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10345 wxPyEndAllowThreads(__tstate);
10346 if (PyErr_Occurred()) SWIG_fail;
10347 }
10348 {
10349 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10350 }
10351 {
10352 if (temp3)
10353 delete arg3;
10354 }
10355 return resultobj;
10356 fail:
10357 {
10358 if (temp3)
10359 delete arg3;
10360 }
10361 return NULL;
10362 }
10363
10364
10365 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10366 PyObject *resultobj = 0;
10367 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10368 wxString *arg2 = 0 ;
10369 int arg3 = (int) 0 ;
10370 wxString result;
10371 void *argp1 = 0 ;
10372 int res1 = 0 ;
10373 bool temp2 = false ;
10374 int val3 ;
10375 int ecode3 = 0 ;
10376 PyObject * obj0 = 0 ;
10377 PyObject * obj1 = 0 ;
10378 PyObject * obj2 = 0 ;
10379 char * kwnames[] = {
10380 (char *) "self",(char *) "spec",(char *) "flags", NULL
10381 };
10382
10383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10385 if (!SWIG_IsOK(res1)) {
10386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10387 }
10388 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10389 {
10390 arg2 = wxString_in_helper(obj1);
10391 if (arg2 == NULL) SWIG_fail;
10392 temp2 = true;
10393 }
10394 if (obj2) {
10395 ecode3 = SWIG_AsVal_int(obj2, &val3);
10396 if (!SWIG_IsOK(ecode3)) {
10397 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10398 }
10399 arg3 = static_cast< int >(val3);
10400 }
10401 {
10402 PyThreadState* __tstate = wxPyBeginAllowThreads();
10403 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10404 wxPyEndAllowThreads(__tstate);
10405 if (PyErr_Occurred()) SWIG_fail;
10406 }
10407 {
10408 #if wxUSE_UNICODE
10409 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10410 #else
10411 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10412 #endif
10413 }
10414 {
10415 if (temp2)
10416 delete arg2;
10417 }
10418 return resultobj;
10419 fail:
10420 {
10421 if (temp2)
10422 delete arg2;
10423 }
10424 return NULL;
10425 }
10426
10427
10428 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10429 PyObject *resultobj = 0;
10430 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10431 wxString result;
10432 void *argp1 = 0 ;
10433 int res1 = 0 ;
10434 PyObject *swig_obj[1] ;
10435
10436 if (!args) SWIG_fail;
10437 swig_obj[0] = args;
10438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10439 if (!SWIG_IsOK(res1)) {
10440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10441 }
10442 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10443 {
10444 PyThreadState* __tstate = wxPyBeginAllowThreads();
10445 result = (arg1)->FindNext();
10446 wxPyEndAllowThreads(__tstate);
10447 if (PyErr_Occurred()) SWIG_fail;
10448 }
10449 {
10450 #if wxUSE_UNICODE
10451 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10452 #else
10453 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10454 #endif
10455 }
10456 return resultobj;
10457 fail:
10458 return NULL;
10459 }
10460
10461
10462 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10463 PyObject *resultobj = 0;
10464 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10465 wxString *arg2 = 0 ;
10466 wxString result;
10467 void *argp1 = 0 ;
10468 int res1 = 0 ;
10469 bool temp2 = false ;
10470 PyObject * obj0 = 0 ;
10471 PyObject * obj1 = 0 ;
10472 char * kwnames[] = {
10473 (char *) "self",(char *) "location", NULL
10474 };
10475
10476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10478 if (!SWIG_IsOK(res1)) {
10479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10480 }
10481 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10482 {
10483 arg2 = wxString_in_helper(obj1);
10484 if (arg2 == NULL) SWIG_fail;
10485 temp2 = true;
10486 }
10487 {
10488 PyThreadState* __tstate = wxPyBeginAllowThreads();
10489 result = (arg1)->GetProtocol((wxString const &)*arg2);
10490 wxPyEndAllowThreads(__tstate);
10491 if (PyErr_Occurred()) SWIG_fail;
10492 }
10493 {
10494 #if wxUSE_UNICODE
10495 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10496 #else
10497 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10498 #endif
10499 }
10500 {
10501 if (temp2)
10502 delete arg2;
10503 }
10504 return resultobj;
10505 fail:
10506 {
10507 if (temp2)
10508 delete arg2;
10509 }
10510 return NULL;
10511 }
10512
10513
10514 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10515 PyObject *resultobj = 0;
10516 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10517 wxString *arg2 = 0 ;
10518 wxString result;
10519 void *argp1 = 0 ;
10520 int res1 = 0 ;
10521 bool temp2 = false ;
10522 PyObject * obj0 = 0 ;
10523 PyObject * obj1 = 0 ;
10524 char * kwnames[] = {
10525 (char *) "self",(char *) "location", NULL
10526 };
10527
10528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10530 if (!SWIG_IsOK(res1)) {
10531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10532 }
10533 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10534 {
10535 arg2 = wxString_in_helper(obj1);
10536 if (arg2 == NULL) SWIG_fail;
10537 temp2 = true;
10538 }
10539 {
10540 PyThreadState* __tstate = wxPyBeginAllowThreads();
10541 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10542 wxPyEndAllowThreads(__tstate);
10543 if (PyErr_Occurred()) SWIG_fail;
10544 }
10545 {
10546 #if wxUSE_UNICODE
10547 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10548 #else
10549 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10550 #endif
10551 }
10552 {
10553 if (temp2)
10554 delete arg2;
10555 }
10556 return resultobj;
10557 fail:
10558 {
10559 if (temp2)
10560 delete arg2;
10561 }
10562 return NULL;
10563 }
10564
10565
10566 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10567 PyObject *resultobj = 0;
10568 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10569 wxString *arg2 = 0 ;
10570 wxString result;
10571 void *argp1 = 0 ;
10572 int res1 = 0 ;
10573 bool temp2 = false ;
10574 PyObject * obj0 = 0 ;
10575 PyObject * obj1 = 0 ;
10576 char * kwnames[] = {
10577 (char *) "self",(char *) "location", NULL
10578 };
10579
10580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10582 if (!SWIG_IsOK(res1)) {
10583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10584 }
10585 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10586 {
10587 arg2 = wxString_in_helper(obj1);
10588 if (arg2 == NULL) SWIG_fail;
10589 temp2 = true;
10590 }
10591 {
10592 PyThreadState* __tstate = wxPyBeginAllowThreads();
10593 result = (arg1)->GetAnchor((wxString const &)*arg2);
10594 wxPyEndAllowThreads(__tstate);
10595 if (PyErr_Occurred()) SWIG_fail;
10596 }
10597 {
10598 #if wxUSE_UNICODE
10599 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10600 #else
10601 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10602 #endif
10603 }
10604 {
10605 if (temp2)
10606 delete arg2;
10607 }
10608 return resultobj;
10609 fail:
10610 {
10611 if (temp2)
10612 delete arg2;
10613 }
10614 return NULL;
10615 }
10616
10617
10618 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10619 PyObject *resultobj = 0;
10620 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10621 wxString *arg2 = 0 ;
10622 wxString result;
10623 void *argp1 = 0 ;
10624 int res1 = 0 ;
10625 bool temp2 = false ;
10626 PyObject * obj0 = 0 ;
10627 PyObject * obj1 = 0 ;
10628 char * kwnames[] = {
10629 (char *) "self",(char *) "location", NULL
10630 };
10631
10632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10634 if (!SWIG_IsOK(res1)) {
10635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10636 }
10637 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10638 {
10639 arg2 = wxString_in_helper(obj1);
10640 if (arg2 == NULL) SWIG_fail;
10641 temp2 = true;
10642 }
10643 {
10644 PyThreadState* __tstate = wxPyBeginAllowThreads();
10645 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10646 wxPyEndAllowThreads(__tstate);
10647 if (PyErr_Occurred()) SWIG_fail;
10648 }
10649 {
10650 #if wxUSE_UNICODE
10651 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10652 #else
10653 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10654 #endif
10655 }
10656 {
10657 if (temp2)
10658 delete arg2;
10659 }
10660 return resultobj;
10661 fail:
10662 {
10663 if (temp2)
10664 delete arg2;
10665 }
10666 return NULL;
10667 }
10668
10669
10670 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10671 PyObject *resultobj = 0;
10672 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10673 wxString *arg2 = 0 ;
10674 wxString result;
10675 void *argp1 = 0 ;
10676 int res1 = 0 ;
10677 bool temp2 = false ;
10678 PyObject * obj0 = 0 ;
10679 PyObject * obj1 = 0 ;
10680 char * kwnames[] = {
10681 (char *) "self",(char *) "location", NULL
10682 };
10683
10684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10686 if (!SWIG_IsOK(res1)) {
10687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10688 }
10689 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10690 {
10691 arg2 = wxString_in_helper(obj1);
10692 if (arg2 == NULL) SWIG_fail;
10693 temp2 = true;
10694 }
10695 {
10696 PyThreadState* __tstate = wxPyBeginAllowThreads();
10697 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10698 wxPyEndAllowThreads(__tstate);
10699 if (PyErr_Occurred()) SWIG_fail;
10700 }
10701 {
10702 #if wxUSE_UNICODE
10703 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10704 #else
10705 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10706 #endif
10707 }
10708 {
10709 if (temp2)
10710 delete arg2;
10711 }
10712 return resultobj;
10713 fail:
10714 {
10715 if (temp2)
10716 delete arg2;
10717 }
10718 return NULL;
10719 }
10720
10721
10722 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10723 PyObject *obj;
10724 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10725 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10726 return SWIG_Py_Void();
10727 }
10728
10729 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10730 return SWIG_Python_InitShadowInstance(args);
10731 }
10732
10733 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10734 PyObject *resultobj = 0;
10735 wxFileSystem *result = 0 ;
10736
10737 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10738 {
10739 PyThreadState* __tstate = wxPyBeginAllowThreads();
10740 result = (wxFileSystem *)new wxFileSystem();
10741 wxPyEndAllowThreads(__tstate);
10742 if (PyErr_Occurred()) SWIG_fail;
10743 }
10744 {
10745 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10746 }
10747 return resultobj;
10748 fail:
10749 return NULL;
10750 }
10751
10752
10753 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10754 PyObject *resultobj = 0;
10755 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10756 void *argp1 = 0 ;
10757 int res1 = 0 ;
10758 PyObject *swig_obj[1] ;
10759
10760 if (!args) SWIG_fail;
10761 swig_obj[0] = args;
10762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10763 if (!SWIG_IsOK(res1)) {
10764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10765 }
10766 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10767 {
10768 PyThreadState* __tstate = wxPyBeginAllowThreads();
10769 delete arg1;
10770
10771 wxPyEndAllowThreads(__tstate);
10772 if (PyErr_Occurred()) SWIG_fail;
10773 }
10774 resultobj = SWIG_Py_Void();
10775 return resultobj;
10776 fail:
10777 return NULL;
10778 }
10779
10780
10781 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10782 PyObject *resultobj = 0;
10783 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10784 wxString *arg2 = 0 ;
10785 bool arg3 = (bool) false ;
10786 void *argp1 = 0 ;
10787 int res1 = 0 ;
10788 bool temp2 = false ;
10789 bool val3 ;
10790 int ecode3 = 0 ;
10791 PyObject * obj0 = 0 ;
10792 PyObject * obj1 = 0 ;
10793 PyObject * obj2 = 0 ;
10794 char * kwnames[] = {
10795 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10796 };
10797
10798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10800 if (!SWIG_IsOK(res1)) {
10801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10802 }
10803 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10804 {
10805 arg2 = wxString_in_helper(obj1);
10806 if (arg2 == NULL) SWIG_fail;
10807 temp2 = true;
10808 }
10809 if (obj2) {
10810 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10811 if (!SWIG_IsOK(ecode3)) {
10812 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10813 }
10814 arg3 = static_cast< bool >(val3);
10815 }
10816 {
10817 PyThreadState* __tstate = wxPyBeginAllowThreads();
10818 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10819 wxPyEndAllowThreads(__tstate);
10820 if (PyErr_Occurred()) SWIG_fail;
10821 }
10822 resultobj = SWIG_Py_Void();
10823 {
10824 if (temp2)
10825 delete arg2;
10826 }
10827 return resultobj;
10828 fail:
10829 {
10830 if (temp2)
10831 delete arg2;
10832 }
10833 return NULL;
10834 }
10835
10836
10837 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10838 PyObject *resultobj = 0;
10839 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10840 wxString result;
10841 void *argp1 = 0 ;
10842 int res1 = 0 ;
10843 PyObject *swig_obj[1] ;
10844
10845 if (!args) SWIG_fail;
10846 swig_obj[0] = args;
10847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10848 if (!SWIG_IsOK(res1)) {
10849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10850 }
10851 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10852 {
10853 PyThreadState* __tstate = wxPyBeginAllowThreads();
10854 result = (arg1)->GetPath();
10855 wxPyEndAllowThreads(__tstate);
10856 if (PyErr_Occurred()) SWIG_fail;
10857 }
10858 {
10859 #if wxUSE_UNICODE
10860 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10861 #else
10862 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10863 #endif
10864 }
10865 return resultobj;
10866 fail:
10867 return NULL;
10868 }
10869
10870
10871 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10872 PyObject *resultobj = 0;
10873 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10874 wxString *arg2 = 0 ;
10875 wxFSFile *result = 0 ;
10876 void *argp1 = 0 ;
10877 int res1 = 0 ;
10878 bool temp2 = false ;
10879 PyObject * obj0 = 0 ;
10880 PyObject * obj1 = 0 ;
10881 char * kwnames[] = {
10882 (char *) "self",(char *) "location", NULL
10883 };
10884
10885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10887 if (!SWIG_IsOK(res1)) {
10888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10889 }
10890 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10891 {
10892 arg2 = wxString_in_helper(obj1);
10893 if (arg2 == NULL) SWIG_fail;
10894 temp2 = true;
10895 }
10896 {
10897 PyThreadState* __tstate = wxPyBeginAllowThreads();
10898 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10899 wxPyEndAllowThreads(__tstate);
10900 if (PyErr_Occurred()) SWIG_fail;
10901 }
10902 {
10903 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10904 }
10905 {
10906 if (temp2)
10907 delete arg2;
10908 }
10909 return resultobj;
10910 fail:
10911 {
10912 if (temp2)
10913 delete arg2;
10914 }
10915 return NULL;
10916 }
10917
10918
10919 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10920 PyObject *resultobj = 0;
10921 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10922 wxString *arg2 = 0 ;
10923 int arg3 = (int) 0 ;
10924 wxString result;
10925 void *argp1 = 0 ;
10926 int res1 = 0 ;
10927 bool temp2 = false ;
10928 int val3 ;
10929 int ecode3 = 0 ;
10930 PyObject * obj0 = 0 ;
10931 PyObject * obj1 = 0 ;
10932 PyObject * obj2 = 0 ;
10933 char * kwnames[] = {
10934 (char *) "self",(char *) "spec",(char *) "flags", NULL
10935 };
10936
10937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10939 if (!SWIG_IsOK(res1)) {
10940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10941 }
10942 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10943 {
10944 arg2 = wxString_in_helper(obj1);
10945 if (arg2 == NULL) SWIG_fail;
10946 temp2 = true;
10947 }
10948 if (obj2) {
10949 ecode3 = SWIG_AsVal_int(obj2, &val3);
10950 if (!SWIG_IsOK(ecode3)) {
10951 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
10952 }
10953 arg3 = static_cast< int >(val3);
10954 }
10955 {
10956 PyThreadState* __tstate = wxPyBeginAllowThreads();
10957 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10958 wxPyEndAllowThreads(__tstate);
10959 if (PyErr_Occurred()) SWIG_fail;
10960 }
10961 {
10962 #if wxUSE_UNICODE
10963 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10964 #else
10965 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10966 #endif
10967 }
10968 {
10969 if (temp2)
10970 delete arg2;
10971 }
10972 return resultobj;
10973 fail:
10974 {
10975 if (temp2)
10976 delete arg2;
10977 }
10978 return NULL;
10979 }
10980
10981
10982 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10983 PyObject *resultobj = 0;
10984 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10985 wxString result;
10986 void *argp1 = 0 ;
10987 int res1 = 0 ;
10988 PyObject *swig_obj[1] ;
10989
10990 if (!args) SWIG_fail;
10991 swig_obj[0] = args;
10992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10993 if (!SWIG_IsOK(res1)) {
10994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10995 }
10996 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10997 {
10998 PyThreadState* __tstate = wxPyBeginAllowThreads();
10999 result = (arg1)->FindNext();
11000 wxPyEndAllowThreads(__tstate);
11001 if (PyErr_Occurred()) SWIG_fail;
11002 }
11003 {
11004 #if wxUSE_UNICODE
11005 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11006 #else
11007 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11008 #endif
11009 }
11010 return resultobj;
11011 fail:
11012 return NULL;
11013 }
11014
11015
11016 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11017 PyObject *resultobj = 0;
11018 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
11019 int res1 = 0 ;
11020 PyObject * obj0 = 0 ;
11021 char * kwnames[] = {
11022 (char *) "handler", NULL
11023 };
11024
11025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
11026 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
11027 if (!SWIG_IsOK(res1)) {
11028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
11029 }
11030 {
11031 PyThreadState* __tstate = wxPyBeginAllowThreads();
11032 wxFileSystem::AddHandler(arg1);
11033 wxPyEndAllowThreads(__tstate);
11034 if (PyErr_Occurred()) SWIG_fail;
11035 }
11036 resultobj = SWIG_Py_Void();
11037 return resultobj;
11038 fail:
11039 return NULL;
11040 }
11041
11042
11043 SWIGINTERN PyObject *_wrap_FileSystem_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11044 PyObject *resultobj = 0;
11045 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
11046 wxFileSystemHandler *result = 0 ;
11047 void *argp1 = 0 ;
11048 int res1 = 0 ;
11049 PyObject * obj0 = 0 ;
11050 char * kwnames[] = {
11051 (char *) "handler", NULL
11052 };
11053
11054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_RemoveHandler",kwnames,&obj0)) SWIG_fail;
11055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystemHandler, 0 | 0 );
11056 if (!SWIG_IsOK(res1)) {
11057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_RemoveHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
11058 }
11059 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
11060 {
11061 PyThreadState* __tstate = wxPyBeginAllowThreads();
11062 result = (wxFileSystemHandler *)wxFileSystem::RemoveHandler(arg1);
11063 wxPyEndAllowThreads(__tstate);
11064 if (PyErr_Occurred()) SWIG_fail;
11065 }
11066 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_OWN | 0 );
11067 return resultobj;
11068 fail:
11069 return NULL;
11070 }
11071
11072
11073 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11074 PyObject *resultobj = 0;
11075
11076 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
11077 {
11078 PyThreadState* __tstate = wxPyBeginAllowThreads();
11079 wxFileSystem::CleanUpHandlers();
11080 wxPyEndAllowThreads(__tstate);
11081 if (PyErr_Occurred()) SWIG_fail;
11082 }
11083 resultobj = SWIG_Py_Void();
11084 return resultobj;
11085 fail:
11086 return NULL;
11087 }
11088
11089
11090 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11091 PyObject *resultobj = 0;
11092 wxString *arg1 = 0 ;
11093 wxString result;
11094 bool temp1 = false ;
11095 PyObject * obj0 = 0 ;
11096 char * kwnames[] = {
11097 (char *) "filename", NULL
11098 };
11099
11100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
11101 {
11102 arg1 = wxString_in_helper(obj0);
11103 if (arg1 == NULL) SWIG_fail;
11104 temp1 = true;
11105 }
11106 {
11107 PyThreadState* __tstate = wxPyBeginAllowThreads();
11108 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
11109 wxPyEndAllowThreads(__tstate);
11110 if (PyErr_Occurred()) SWIG_fail;
11111 }
11112 {
11113 #if wxUSE_UNICODE
11114 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11115 #else
11116 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11117 #endif
11118 }
11119 {
11120 if (temp1)
11121 delete arg1;
11122 }
11123 return resultobj;
11124 fail:
11125 {
11126 if (temp1)
11127 delete arg1;
11128 }
11129 return NULL;
11130 }
11131
11132
11133 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11134 PyObject *resultobj = 0;
11135 wxString *arg1 = 0 ;
11136 wxString result;
11137 bool temp1 = false ;
11138 PyObject * obj0 = 0 ;
11139 char * kwnames[] = {
11140 (char *) "url", NULL
11141 };
11142
11143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
11144 {
11145 arg1 = wxString_in_helper(obj0);
11146 if (arg1 == NULL) SWIG_fail;
11147 temp1 = true;
11148 }
11149 {
11150 PyThreadState* __tstate = wxPyBeginAllowThreads();
11151 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
11152 wxPyEndAllowThreads(__tstate);
11153 if (PyErr_Occurred()) SWIG_fail;
11154 }
11155 {
11156 #if wxUSE_UNICODE
11157 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11158 #else
11159 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11160 #endif
11161 }
11162 {
11163 if (temp1)
11164 delete arg1;
11165 }
11166 return resultobj;
11167 fail:
11168 {
11169 if (temp1)
11170 delete arg1;
11171 }
11172 return NULL;
11173 }
11174
11175
11176 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11177 PyObject *obj;
11178 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11179 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
11180 return SWIG_Py_Void();
11181 }
11182
11183 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11184 return SWIG_Python_InitShadowInstance(args);
11185 }
11186
11187 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11188 PyObject *resultobj = 0;
11189 wxInternetFSHandler *result = 0 ;
11190
11191 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
11192 {
11193 PyThreadState* __tstate = wxPyBeginAllowThreads();
11194 result = (wxInternetFSHandler *)new wxInternetFSHandler();
11195 wxPyEndAllowThreads(__tstate);
11196 if (PyErr_Occurred()) SWIG_fail;
11197 }
11198 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
11199 return resultobj;
11200 fail:
11201 return NULL;
11202 }
11203
11204
11205 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11206 PyObject *resultobj = 0;
11207 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11208 wxString *arg2 = 0 ;
11209 bool result;
11210 void *argp1 = 0 ;
11211 int res1 = 0 ;
11212 bool temp2 = false ;
11213 PyObject * obj0 = 0 ;
11214 PyObject * obj1 = 0 ;
11215 char * kwnames[] = {
11216 (char *) "self",(char *) "location", NULL
11217 };
11218
11219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11221 if (!SWIG_IsOK(res1)) {
11222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11223 }
11224 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11225 {
11226 arg2 = wxString_in_helper(obj1);
11227 if (arg2 == NULL) SWIG_fail;
11228 temp2 = true;
11229 }
11230 {
11231 PyThreadState* __tstate = wxPyBeginAllowThreads();
11232 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11233 wxPyEndAllowThreads(__tstate);
11234 if (PyErr_Occurred()) SWIG_fail;
11235 }
11236 {
11237 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11238 }
11239 {
11240 if (temp2)
11241 delete arg2;
11242 }
11243 return resultobj;
11244 fail:
11245 {
11246 if (temp2)
11247 delete arg2;
11248 }
11249 return NULL;
11250 }
11251
11252
11253 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11254 PyObject *resultobj = 0;
11255 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11256 wxFileSystem *arg2 = 0 ;
11257 wxString *arg3 = 0 ;
11258 wxFSFile *result = 0 ;
11259 void *argp1 = 0 ;
11260 int res1 = 0 ;
11261 void *argp2 = 0 ;
11262 int res2 = 0 ;
11263 bool temp3 = false ;
11264 PyObject * obj0 = 0 ;
11265 PyObject * obj1 = 0 ;
11266 PyObject * obj2 = 0 ;
11267 char * kwnames[] = {
11268 (char *) "self",(char *) "fs",(char *) "location", NULL
11269 };
11270
11271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11273 if (!SWIG_IsOK(res1)) {
11274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11275 }
11276 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11277 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11278 if (!SWIG_IsOK(res2)) {
11279 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11280 }
11281 if (!argp2) {
11282 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11283 }
11284 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11285 {
11286 arg3 = wxString_in_helper(obj2);
11287 if (arg3 == NULL) SWIG_fail;
11288 temp3 = true;
11289 }
11290 {
11291 PyThreadState* __tstate = wxPyBeginAllowThreads();
11292 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11293 wxPyEndAllowThreads(__tstate);
11294 if (PyErr_Occurred()) SWIG_fail;
11295 }
11296 {
11297 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11298 }
11299 {
11300 if (temp3)
11301 delete arg3;
11302 }
11303 return resultobj;
11304 fail:
11305 {
11306 if (temp3)
11307 delete arg3;
11308 }
11309 return NULL;
11310 }
11311
11312
11313 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11314 PyObject *obj;
11315 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11316 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11317 return SWIG_Py_Void();
11318 }
11319
11320 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11321 return SWIG_Python_InitShadowInstance(args);
11322 }
11323
11324 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11325 PyObject *resultobj = 0;
11326 wxZipFSHandler *result = 0 ;
11327
11328 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11329 {
11330 PyThreadState* __tstate = wxPyBeginAllowThreads();
11331 result = (wxZipFSHandler *)new wxZipFSHandler();
11332 wxPyEndAllowThreads(__tstate);
11333 if (PyErr_Occurred()) SWIG_fail;
11334 }
11335 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11336 return resultobj;
11337 fail:
11338 return NULL;
11339 }
11340
11341
11342 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11343 PyObject *resultobj = 0;
11344 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11345 wxString *arg2 = 0 ;
11346 bool result;
11347 void *argp1 = 0 ;
11348 int res1 = 0 ;
11349 bool temp2 = false ;
11350 PyObject * obj0 = 0 ;
11351 PyObject * obj1 = 0 ;
11352 char * kwnames[] = {
11353 (char *) "self",(char *) "location", NULL
11354 };
11355
11356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11358 if (!SWIG_IsOK(res1)) {
11359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11360 }
11361 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11362 {
11363 arg2 = wxString_in_helper(obj1);
11364 if (arg2 == NULL) SWIG_fail;
11365 temp2 = true;
11366 }
11367 {
11368 PyThreadState* __tstate = wxPyBeginAllowThreads();
11369 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11370 wxPyEndAllowThreads(__tstate);
11371 if (PyErr_Occurred()) SWIG_fail;
11372 }
11373 {
11374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11375 }
11376 {
11377 if (temp2)
11378 delete arg2;
11379 }
11380 return resultobj;
11381 fail:
11382 {
11383 if (temp2)
11384 delete arg2;
11385 }
11386 return NULL;
11387 }
11388
11389
11390 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11391 PyObject *resultobj = 0;
11392 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11393 wxFileSystem *arg2 = 0 ;
11394 wxString *arg3 = 0 ;
11395 wxFSFile *result = 0 ;
11396 void *argp1 = 0 ;
11397 int res1 = 0 ;
11398 void *argp2 = 0 ;
11399 int res2 = 0 ;
11400 bool temp3 = false ;
11401 PyObject * obj0 = 0 ;
11402 PyObject * obj1 = 0 ;
11403 PyObject * obj2 = 0 ;
11404 char * kwnames[] = {
11405 (char *) "self",(char *) "fs",(char *) "location", NULL
11406 };
11407
11408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11410 if (!SWIG_IsOK(res1)) {
11411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11412 }
11413 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11414 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11415 if (!SWIG_IsOK(res2)) {
11416 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11417 }
11418 if (!argp2) {
11419 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11420 }
11421 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11422 {
11423 arg3 = wxString_in_helper(obj2);
11424 if (arg3 == NULL) SWIG_fail;
11425 temp3 = true;
11426 }
11427 {
11428 PyThreadState* __tstate = wxPyBeginAllowThreads();
11429 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11430 wxPyEndAllowThreads(__tstate);
11431 if (PyErr_Occurred()) SWIG_fail;
11432 }
11433 {
11434 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11435 }
11436 {
11437 if (temp3)
11438 delete arg3;
11439 }
11440 return resultobj;
11441 fail:
11442 {
11443 if (temp3)
11444 delete arg3;
11445 }
11446 return NULL;
11447 }
11448
11449
11450 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11451 PyObject *resultobj = 0;
11452 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11453 wxString *arg2 = 0 ;
11454 int arg3 = (int) 0 ;
11455 wxString result;
11456 void *argp1 = 0 ;
11457 int res1 = 0 ;
11458 bool temp2 = false ;
11459 int val3 ;
11460 int ecode3 = 0 ;
11461 PyObject * obj0 = 0 ;
11462 PyObject * obj1 = 0 ;
11463 PyObject * obj2 = 0 ;
11464 char * kwnames[] = {
11465 (char *) "self",(char *) "spec",(char *) "flags", NULL
11466 };
11467
11468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11470 if (!SWIG_IsOK(res1)) {
11471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11472 }
11473 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11474 {
11475 arg2 = wxString_in_helper(obj1);
11476 if (arg2 == NULL) SWIG_fail;
11477 temp2 = true;
11478 }
11479 if (obj2) {
11480 ecode3 = SWIG_AsVal_int(obj2, &val3);
11481 if (!SWIG_IsOK(ecode3)) {
11482 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11483 }
11484 arg3 = static_cast< int >(val3);
11485 }
11486 {
11487 PyThreadState* __tstate = wxPyBeginAllowThreads();
11488 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11489 wxPyEndAllowThreads(__tstate);
11490 if (PyErr_Occurred()) SWIG_fail;
11491 }
11492 {
11493 #if wxUSE_UNICODE
11494 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11495 #else
11496 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11497 #endif
11498 }
11499 {
11500 if (temp2)
11501 delete arg2;
11502 }
11503 return resultobj;
11504 fail:
11505 {
11506 if (temp2)
11507 delete arg2;
11508 }
11509 return NULL;
11510 }
11511
11512
11513 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11514 PyObject *resultobj = 0;
11515 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11516 wxString result;
11517 void *argp1 = 0 ;
11518 int res1 = 0 ;
11519 PyObject *swig_obj[1] ;
11520
11521 if (!args) SWIG_fail;
11522 swig_obj[0] = args;
11523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11524 if (!SWIG_IsOK(res1)) {
11525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11526 }
11527 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11528 {
11529 PyThreadState* __tstate = wxPyBeginAllowThreads();
11530 result = (arg1)->FindNext();
11531 wxPyEndAllowThreads(__tstate);
11532 if (PyErr_Occurred()) SWIG_fail;
11533 }
11534 {
11535 #if wxUSE_UNICODE
11536 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11537 #else
11538 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11539 #endif
11540 }
11541 return resultobj;
11542 fail:
11543 return NULL;
11544 }
11545
11546
11547 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11548 PyObject *obj;
11549 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11550 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11551 return SWIG_Py_Void();
11552 }
11553
11554 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11555 return SWIG_Python_InitShadowInstance(args);
11556 }
11557
11558 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11559 PyObject *resultobj = 0;
11560 wxString *arg1 = 0 ;
11561 wxImage *arg2 = 0 ;
11562 long arg3 ;
11563 bool temp1 = false ;
11564 void *argp2 = 0 ;
11565 int res2 = 0 ;
11566 long val3 ;
11567 int ecode3 = 0 ;
11568 PyObject * obj0 = 0 ;
11569 PyObject * obj1 = 0 ;
11570 PyObject * obj2 = 0 ;
11571 char * kwnames[] = {
11572 (char *) "filename",(char *) "image",(char *) "type", NULL
11573 };
11574
11575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11576 {
11577 arg1 = wxString_in_helper(obj0);
11578 if (arg1 == NULL) SWIG_fail;
11579 temp1 = true;
11580 }
11581 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11582 if (!SWIG_IsOK(res2)) {
11583 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11584 }
11585 if (!argp2) {
11586 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11587 }
11588 arg2 = reinterpret_cast< wxImage * >(argp2);
11589 ecode3 = SWIG_AsVal_long(obj2, &val3);
11590 if (!SWIG_IsOK(ecode3)) {
11591 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11592 }
11593 arg3 = static_cast< long >(val3);
11594 {
11595 PyThreadState* __tstate = wxPyBeginAllowThreads();
11596 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11597 wxPyEndAllowThreads(__tstate);
11598 if (PyErr_Occurred()) SWIG_fail;
11599 }
11600 resultobj = SWIG_Py_Void();
11601 {
11602 if (temp1)
11603 delete arg1;
11604 }
11605 return resultobj;
11606 fail:
11607 {
11608 if (temp1)
11609 delete arg1;
11610 }
11611 return NULL;
11612 }
11613
11614
11615 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11616 PyObject *resultobj = 0;
11617 wxString *arg1 = 0 ;
11618 wxBitmap *arg2 = 0 ;
11619 long arg3 ;
11620 bool temp1 = false ;
11621 void *argp2 = 0 ;
11622 int res2 = 0 ;
11623 long val3 ;
11624 int ecode3 = 0 ;
11625 PyObject * obj0 = 0 ;
11626 PyObject * obj1 = 0 ;
11627 PyObject * obj2 = 0 ;
11628 char * kwnames[] = {
11629 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11630 };
11631
11632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11633 {
11634 arg1 = wxString_in_helper(obj0);
11635 if (arg1 == NULL) SWIG_fail;
11636 temp1 = true;
11637 }
11638 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11639 if (!SWIG_IsOK(res2)) {
11640 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11641 }
11642 if (!argp2) {
11643 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11644 }
11645 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11646 ecode3 = SWIG_AsVal_long(obj2, &val3);
11647 if (!SWIG_IsOK(ecode3)) {
11648 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11649 }
11650 arg3 = static_cast< long >(val3);
11651 {
11652 PyThreadState* __tstate = wxPyBeginAllowThreads();
11653 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11654 wxPyEndAllowThreads(__tstate);
11655 if (PyErr_Occurred()) SWIG_fail;
11656 }
11657 resultobj = SWIG_Py_Void();
11658 {
11659 if (temp1)
11660 delete arg1;
11661 }
11662 return resultobj;
11663 fail:
11664 {
11665 if (temp1)
11666 delete arg1;
11667 }
11668 return NULL;
11669 }
11670
11671
11672 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11673 PyObject *resultobj = 0;
11674 wxString *arg1 = 0 ;
11675 PyObject *arg2 = (PyObject *) 0 ;
11676 bool temp1 = false ;
11677 PyObject * obj0 = 0 ;
11678 PyObject * obj1 = 0 ;
11679 char * kwnames[] = {
11680 (char *) "filename",(char *) "data", NULL
11681 };
11682
11683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11684 {
11685 arg1 = wxString_in_helper(obj0);
11686 if (arg1 == NULL) SWIG_fail;
11687 temp1 = true;
11688 }
11689 arg2 = obj1;
11690 {
11691 PyThreadState* __tstate = wxPyBeginAllowThreads();
11692 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11693 wxPyEndAllowThreads(__tstate);
11694 if (PyErr_Occurred()) SWIG_fail;
11695 }
11696 resultobj = SWIG_Py_Void();
11697 {
11698 if (temp1)
11699 delete arg1;
11700 }
11701 return resultobj;
11702 fail:
11703 {
11704 if (temp1)
11705 delete arg1;
11706 }
11707 return NULL;
11708 }
11709
11710
11711 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11712 PyObject *resultobj = 0;
11713 wxMemoryFSHandler *result = 0 ;
11714
11715 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11716 {
11717 PyThreadState* __tstate = wxPyBeginAllowThreads();
11718 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11719 wxPyEndAllowThreads(__tstate);
11720 if (PyErr_Occurred()) SWIG_fail;
11721 }
11722 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11723 return resultobj;
11724 fail:
11725 return NULL;
11726 }
11727
11728
11729 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11730 PyObject *resultobj = 0;
11731 wxString *arg1 = 0 ;
11732 bool temp1 = false ;
11733 PyObject * obj0 = 0 ;
11734 char * kwnames[] = {
11735 (char *) "filename", NULL
11736 };
11737
11738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11739 {
11740 arg1 = wxString_in_helper(obj0);
11741 if (arg1 == NULL) SWIG_fail;
11742 temp1 = true;
11743 }
11744 {
11745 PyThreadState* __tstate = wxPyBeginAllowThreads();
11746 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11747 wxPyEndAllowThreads(__tstate);
11748 if (PyErr_Occurred()) SWIG_fail;
11749 }
11750 resultobj = SWIG_Py_Void();
11751 {
11752 if (temp1)
11753 delete arg1;
11754 }
11755 return resultobj;
11756 fail:
11757 {
11758 if (temp1)
11759 delete arg1;
11760 }
11761 return NULL;
11762 }
11763
11764
11765 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11766 PyObject *resultobj = 0;
11767 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11768 wxString *arg2 = 0 ;
11769 bool result;
11770 void *argp1 = 0 ;
11771 int res1 = 0 ;
11772 bool temp2 = false ;
11773 PyObject * obj0 = 0 ;
11774 PyObject * obj1 = 0 ;
11775 char * kwnames[] = {
11776 (char *) "self",(char *) "location", NULL
11777 };
11778
11779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11781 if (!SWIG_IsOK(res1)) {
11782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11783 }
11784 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11785 {
11786 arg2 = wxString_in_helper(obj1);
11787 if (arg2 == NULL) SWIG_fail;
11788 temp2 = true;
11789 }
11790 {
11791 PyThreadState* __tstate = wxPyBeginAllowThreads();
11792 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11793 wxPyEndAllowThreads(__tstate);
11794 if (PyErr_Occurred()) SWIG_fail;
11795 }
11796 {
11797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11798 }
11799 {
11800 if (temp2)
11801 delete arg2;
11802 }
11803 return resultobj;
11804 fail:
11805 {
11806 if (temp2)
11807 delete arg2;
11808 }
11809 return NULL;
11810 }
11811
11812
11813 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11814 PyObject *resultobj = 0;
11815 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11816 wxFileSystem *arg2 = 0 ;
11817 wxString *arg3 = 0 ;
11818 wxFSFile *result = 0 ;
11819 void *argp1 = 0 ;
11820 int res1 = 0 ;
11821 void *argp2 = 0 ;
11822 int res2 = 0 ;
11823 bool temp3 = false ;
11824 PyObject * obj0 = 0 ;
11825 PyObject * obj1 = 0 ;
11826 PyObject * obj2 = 0 ;
11827 char * kwnames[] = {
11828 (char *) "self",(char *) "fs",(char *) "location", NULL
11829 };
11830
11831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11833 if (!SWIG_IsOK(res1)) {
11834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11835 }
11836 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11837 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11838 if (!SWIG_IsOK(res2)) {
11839 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11840 }
11841 if (!argp2) {
11842 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11843 }
11844 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11845 {
11846 arg3 = wxString_in_helper(obj2);
11847 if (arg3 == NULL) SWIG_fail;
11848 temp3 = true;
11849 }
11850 {
11851 PyThreadState* __tstate = wxPyBeginAllowThreads();
11852 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11853 wxPyEndAllowThreads(__tstate);
11854 if (PyErr_Occurred()) SWIG_fail;
11855 }
11856 {
11857 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11858 }
11859 {
11860 if (temp3)
11861 delete arg3;
11862 }
11863 return resultobj;
11864 fail:
11865 {
11866 if (temp3)
11867 delete arg3;
11868 }
11869 return NULL;
11870 }
11871
11872
11873 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11874 PyObject *resultobj = 0;
11875 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11876 wxString *arg2 = 0 ;
11877 int arg3 = (int) 0 ;
11878 wxString result;
11879 void *argp1 = 0 ;
11880 int res1 = 0 ;
11881 bool temp2 = false ;
11882 int val3 ;
11883 int ecode3 = 0 ;
11884 PyObject * obj0 = 0 ;
11885 PyObject * obj1 = 0 ;
11886 PyObject * obj2 = 0 ;
11887 char * kwnames[] = {
11888 (char *) "self",(char *) "spec",(char *) "flags", NULL
11889 };
11890
11891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11893 if (!SWIG_IsOK(res1)) {
11894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11895 }
11896 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11897 {
11898 arg2 = wxString_in_helper(obj1);
11899 if (arg2 == NULL) SWIG_fail;
11900 temp2 = true;
11901 }
11902 if (obj2) {
11903 ecode3 = SWIG_AsVal_int(obj2, &val3);
11904 if (!SWIG_IsOK(ecode3)) {
11905 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11906 }
11907 arg3 = static_cast< int >(val3);
11908 }
11909 {
11910 PyThreadState* __tstate = wxPyBeginAllowThreads();
11911 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11912 wxPyEndAllowThreads(__tstate);
11913 if (PyErr_Occurred()) SWIG_fail;
11914 }
11915 {
11916 #if wxUSE_UNICODE
11917 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11918 #else
11919 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11920 #endif
11921 }
11922 {
11923 if (temp2)
11924 delete arg2;
11925 }
11926 return resultobj;
11927 fail:
11928 {
11929 if (temp2)
11930 delete arg2;
11931 }
11932 return NULL;
11933 }
11934
11935
11936 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11937 PyObject *resultobj = 0;
11938 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11939 wxString result;
11940 void *argp1 = 0 ;
11941 int res1 = 0 ;
11942 PyObject *swig_obj[1] ;
11943
11944 if (!args) SWIG_fail;
11945 swig_obj[0] = args;
11946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11947 if (!SWIG_IsOK(res1)) {
11948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11949 }
11950 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11951 {
11952 PyThreadState* __tstate = wxPyBeginAllowThreads();
11953 result = (arg1)->FindNext();
11954 wxPyEndAllowThreads(__tstate);
11955 if (PyErr_Occurred()) SWIG_fail;
11956 }
11957 {
11958 #if wxUSE_UNICODE
11959 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11960 #else
11961 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11962 #endif
11963 }
11964 return resultobj;
11965 fail:
11966 return NULL;
11967 }
11968
11969
11970 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11971 PyObject *obj;
11972 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11973 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
11974 return SWIG_Py_Void();
11975 }
11976
11977 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11978 return SWIG_Python_InitShadowInstance(args);
11979 }
11980
11981 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11982 PyObject *resultobj = 0;
11983 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11984 wxString result;
11985 void *argp1 = 0 ;
11986 int res1 = 0 ;
11987 PyObject *swig_obj[1] ;
11988
11989 if (!args) SWIG_fail;
11990 swig_obj[0] = args;
11991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11992 if (!SWIG_IsOK(res1)) {
11993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11994 }
11995 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11996 {
11997 PyThreadState* __tstate = wxPyBeginAllowThreads();
11998 result = (arg1)->GetName();
11999 wxPyEndAllowThreads(__tstate);
12000 if (PyErr_Occurred()) SWIG_fail;
12001 }
12002 {
12003 #if wxUSE_UNICODE
12004 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12005 #else
12006 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12007 #endif
12008 }
12009 return resultobj;
12010 fail:
12011 return NULL;
12012 }
12013
12014
12015 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12016 PyObject *resultobj = 0;
12017 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12018 wxString result;
12019 void *argp1 = 0 ;
12020 int res1 = 0 ;
12021 PyObject *swig_obj[1] ;
12022
12023 if (!args) SWIG_fail;
12024 swig_obj[0] = args;
12025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12026 if (!SWIG_IsOK(res1)) {
12027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12028 }
12029 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12030 {
12031 PyThreadState* __tstate = wxPyBeginAllowThreads();
12032 result = (arg1)->GetExtension();
12033 wxPyEndAllowThreads(__tstate);
12034 if (PyErr_Occurred()) SWIG_fail;
12035 }
12036 {
12037 #if wxUSE_UNICODE
12038 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12039 #else
12040 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12041 #endif
12042 }
12043 return resultobj;
12044 fail:
12045 return NULL;
12046 }
12047
12048
12049 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12050 PyObject *resultobj = 0;
12051 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12052 long result;
12053 void *argp1 = 0 ;
12054 int res1 = 0 ;
12055 PyObject *swig_obj[1] ;
12056
12057 if (!args) SWIG_fail;
12058 swig_obj[0] = args;
12059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12060 if (!SWIG_IsOK(res1)) {
12061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12062 }
12063 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12064 {
12065 PyThreadState* __tstate = wxPyBeginAllowThreads();
12066 result = (long)(arg1)->GetType();
12067 wxPyEndAllowThreads(__tstate);
12068 if (PyErr_Occurred()) SWIG_fail;
12069 }
12070 resultobj = SWIG_From_long(static_cast< long >(result));
12071 return resultobj;
12072 fail:
12073 return NULL;
12074 }
12075
12076
12077 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12078 PyObject *resultobj = 0;
12079 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12080 wxString result;
12081 void *argp1 = 0 ;
12082 int res1 = 0 ;
12083 PyObject *swig_obj[1] ;
12084
12085 if (!args) SWIG_fail;
12086 swig_obj[0] = args;
12087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12088 if (!SWIG_IsOK(res1)) {
12089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12090 }
12091 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12092 {
12093 PyThreadState* __tstate = wxPyBeginAllowThreads();
12094 result = (arg1)->GetMimeType();
12095 wxPyEndAllowThreads(__tstate);
12096 if (PyErr_Occurred()) SWIG_fail;
12097 }
12098 {
12099 #if wxUSE_UNICODE
12100 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12101 #else
12102 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12103 #endif
12104 }
12105 return resultobj;
12106 fail:
12107 return NULL;
12108 }
12109
12110
12111 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12112 PyObject *resultobj = 0;
12113 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12114 wxString *arg2 = 0 ;
12115 bool result;
12116 void *argp1 = 0 ;
12117 int res1 = 0 ;
12118 bool temp2 = false ;
12119 PyObject * obj0 = 0 ;
12120 PyObject * obj1 = 0 ;
12121 char * kwnames[] = {
12122 (char *) "self",(char *) "name", NULL
12123 };
12124
12125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
12126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12127 if (!SWIG_IsOK(res1)) {
12128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12129 }
12130 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12131 {
12132 arg2 = wxString_in_helper(obj1);
12133 if (arg2 == NULL) SWIG_fail;
12134 temp2 = true;
12135 }
12136 {
12137 PyThreadState* __tstate = wxPyBeginAllowThreads();
12138 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
12139 wxPyEndAllowThreads(__tstate);
12140 if (PyErr_Occurred()) SWIG_fail;
12141 }
12142 {
12143 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12144 }
12145 {
12146 if (temp2)
12147 delete arg2;
12148 }
12149 return resultobj;
12150 fail:
12151 {
12152 if (temp2)
12153 delete arg2;
12154 }
12155 return NULL;
12156 }
12157
12158
12159 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12160 PyObject *resultobj = 0;
12161 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12162 wxInputStream *arg2 = 0 ;
12163 bool result;
12164 void *argp1 = 0 ;
12165 int res1 = 0 ;
12166 wxPyInputStream *temp2 ;
12167 bool created2 ;
12168 PyObject * obj0 = 0 ;
12169 PyObject * obj1 = 0 ;
12170 char * kwnames[] = {
12171 (char *) "self",(char *) "stream", NULL
12172 };
12173
12174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
12175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12176 if (!SWIG_IsOK(res1)) {
12177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12178 }
12179 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12180 {
12181 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12182 arg2 = temp2->m_wxis;
12183 created2 = false;
12184 } else {
12185 PyErr_Clear(); // clear the failure of the wxPyConvert above
12186 arg2 = wxPyCBInputStream_create(obj1, false);
12187 if (arg2 == NULL) {
12188 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12189 SWIG_fail;
12190 }
12191 created2 = true;
12192 }
12193 }
12194 {
12195 PyThreadState* __tstate = wxPyBeginAllowThreads();
12196 result = (bool)(arg1)->CanRead(*arg2);
12197 wxPyEndAllowThreads(__tstate);
12198 if (PyErr_Occurred()) SWIG_fail;
12199 }
12200 {
12201 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12202 }
12203 {
12204 if (created2) delete arg2;
12205 }
12206 return resultobj;
12207 fail:
12208 {
12209 if (created2) delete arg2;
12210 }
12211 return NULL;
12212 }
12213
12214
12215 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12216 PyObject *resultobj = 0;
12217 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12218 wxString *arg2 = 0 ;
12219 void *argp1 = 0 ;
12220 int res1 = 0 ;
12221 bool temp2 = false ;
12222 PyObject * obj0 = 0 ;
12223 PyObject * obj1 = 0 ;
12224 char * kwnames[] = {
12225 (char *) "self",(char *) "name", NULL
12226 };
12227
12228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
12229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12230 if (!SWIG_IsOK(res1)) {
12231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12232 }
12233 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12234 {
12235 arg2 = wxString_in_helper(obj1);
12236 if (arg2 == NULL) SWIG_fail;
12237 temp2 = true;
12238 }
12239 {
12240 PyThreadState* __tstate = wxPyBeginAllowThreads();
12241 (arg1)->SetName((wxString const &)*arg2);
12242 wxPyEndAllowThreads(__tstate);
12243 if (PyErr_Occurred()) SWIG_fail;
12244 }
12245 resultobj = SWIG_Py_Void();
12246 {
12247 if (temp2)
12248 delete arg2;
12249 }
12250 return resultobj;
12251 fail:
12252 {
12253 if (temp2)
12254 delete arg2;
12255 }
12256 return NULL;
12257 }
12258
12259
12260 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12261 PyObject *resultobj = 0;
12262 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12263 wxString *arg2 = 0 ;
12264 void *argp1 = 0 ;
12265 int res1 = 0 ;
12266 bool temp2 = false ;
12267 PyObject * obj0 = 0 ;
12268 PyObject * obj1 = 0 ;
12269 char * kwnames[] = {
12270 (char *) "self",(char *) "extension", NULL
12271 };
12272
12273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
12274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12275 if (!SWIG_IsOK(res1)) {
12276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12277 }
12278 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12279 {
12280 arg2 = wxString_in_helper(obj1);
12281 if (arg2 == NULL) SWIG_fail;
12282 temp2 = true;
12283 }
12284 {
12285 PyThreadState* __tstate = wxPyBeginAllowThreads();
12286 (arg1)->SetExtension((wxString const &)*arg2);
12287 wxPyEndAllowThreads(__tstate);
12288 if (PyErr_Occurred()) SWIG_fail;
12289 }
12290 resultobj = SWIG_Py_Void();
12291 {
12292 if (temp2)
12293 delete arg2;
12294 }
12295 return resultobj;
12296 fail:
12297 {
12298 if (temp2)
12299 delete arg2;
12300 }
12301 return NULL;
12302 }
12303
12304
12305 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12306 PyObject *resultobj = 0;
12307 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12308 long arg2 ;
12309 void *argp1 = 0 ;
12310 int res1 = 0 ;
12311 long val2 ;
12312 int ecode2 = 0 ;
12313 PyObject * obj0 = 0 ;
12314 PyObject * obj1 = 0 ;
12315 char * kwnames[] = {
12316 (char *) "self",(char *) "type", NULL
12317 };
12318
12319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
12320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12321 if (!SWIG_IsOK(res1)) {
12322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12323 }
12324 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12325 ecode2 = SWIG_AsVal_long(obj1, &val2);
12326 if (!SWIG_IsOK(ecode2)) {
12327 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
12328 }
12329 arg2 = static_cast< long >(val2);
12330 {
12331 PyThreadState* __tstate = wxPyBeginAllowThreads();
12332 (arg1)->SetType(arg2);
12333 wxPyEndAllowThreads(__tstate);
12334 if (PyErr_Occurred()) SWIG_fail;
12335 }
12336 resultobj = SWIG_Py_Void();
12337 return resultobj;
12338 fail:
12339 return NULL;
12340 }
12341
12342
12343 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12344 PyObject *resultobj = 0;
12345 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12346 wxString *arg2 = 0 ;
12347 void *argp1 = 0 ;
12348 int res1 = 0 ;
12349 bool temp2 = false ;
12350 PyObject * obj0 = 0 ;
12351 PyObject * obj1 = 0 ;
12352 char * kwnames[] = {
12353 (char *) "self",(char *) "mimetype", NULL
12354 };
12355
12356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
12357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12358 if (!SWIG_IsOK(res1)) {
12359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12360 }
12361 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12362 {
12363 arg2 = wxString_in_helper(obj1);
12364 if (arg2 == NULL) SWIG_fail;
12365 temp2 = true;
12366 }
12367 {
12368 PyThreadState* __tstate = wxPyBeginAllowThreads();
12369 (arg1)->SetMimeType((wxString const &)*arg2);
12370 wxPyEndAllowThreads(__tstate);
12371 if (PyErr_Occurred()) SWIG_fail;
12372 }
12373 resultobj = SWIG_Py_Void();
12374 {
12375 if (temp2)
12376 delete arg2;
12377 }
12378 return resultobj;
12379 fail:
12380 {
12381 if (temp2)
12382 delete arg2;
12383 }
12384 return NULL;
12385 }
12386
12387
12388 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12389 PyObject *obj;
12390 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12391 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12392 return SWIG_Py_Void();
12393 }
12394
12395 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12396 PyObject *resultobj = 0;
12397 wxPyImageHandler *result = 0 ;
12398
12399 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12400 {
12401 PyThreadState* __tstate = wxPyBeginAllowThreads();
12402 result = (wxPyImageHandler *)new wxPyImageHandler();
12403 wxPyEndAllowThreads(__tstate);
12404 if (PyErr_Occurred()) SWIG_fail;
12405 }
12406 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12407 return resultobj;
12408 fail:
12409 return NULL;
12410 }
12411
12412
12413 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12414 PyObject *resultobj = 0;
12415 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12416 PyObject *arg2 = (PyObject *) 0 ;
12417 void *argp1 = 0 ;
12418 int res1 = 0 ;
12419 PyObject * obj0 = 0 ;
12420 PyObject * obj1 = 0 ;
12421 char * kwnames[] = {
12422 (char *) "self",(char *) "self", NULL
12423 };
12424
12425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12427 if (!SWIG_IsOK(res1)) {
12428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12429 }
12430 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12431 arg2 = obj1;
12432 {
12433 PyThreadState* __tstate = wxPyBeginAllowThreads();
12434 (arg1)->_SetSelf(arg2);
12435 wxPyEndAllowThreads(__tstate);
12436 if (PyErr_Occurred()) SWIG_fail;
12437 }
12438 resultobj = SWIG_Py_Void();
12439 return resultobj;
12440 fail:
12441 return NULL;
12442 }
12443
12444
12445 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12446 PyObject *obj;
12447 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12448 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12449 return SWIG_Py_Void();
12450 }
12451
12452 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12453 return SWIG_Python_InitShadowInstance(args);
12454 }
12455
12456 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12457 PyObject *resultobj = 0;
12458 wxImageHistogram *result = 0 ;
12459
12460 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12461 {
12462 PyThreadState* __tstate = wxPyBeginAllowThreads();
12463 result = (wxImageHistogram *)new wxImageHistogram();
12464 wxPyEndAllowThreads(__tstate);
12465 if (PyErr_Occurred()) SWIG_fail;
12466 }
12467 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12468 return resultobj;
12469 fail:
12470 return NULL;
12471 }
12472
12473
12474 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12475 PyObject *resultobj = 0;
12476 byte arg1 ;
12477 byte arg2 ;
12478 byte arg3 ;
12479 unsigned long result;
12480 unsigned char val1 ;
12481 int ecode1 = 0 ;
12482 unsigned char val2 ;
12483 int ecode2 = 0 ;
12484 unsigned char val3 ;
12485 int ecode3 = 0 ;
12486 PyObject * obj0 = 0 ;
12487 PyObject * obj1 = 0 ;
12488 PyObject * obj2 = 0 ;
12489 char * kwnames[] = {
12490 (char *) "r",(char *) "g",(char *) "b", NULL
12491 };
12492
12493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12494 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12495 if (!SWIG_IsOK(ecode1)) {
12496 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12497 }
12498 arg1 = static_cast< byte >(val1);
12499 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12500 if (!SWIG_IsOK(ecode2)) {
12501 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12502 }
12503 arg2 = static_cast< byte >(val2);
12504 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12505 if (!SWIG_IsOK(ecode3)) {
12506 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12507 }
12508 arg3 = static_cast< byte >(val3);
12509 {
12510 PyThreadState* __tstate = wxPyBeginAllowThreads();
12511 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12512 wxPyEndAllowThreads(__tstate);
12513 if (PyErr_Occurred()) SWIG_fail;
12514 }
12515 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12516 return resultobj;
12517 fail:
12518 return NULL;
12519 }
12520
12521
12522 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12523 PyObject *resultobj = 0;
12524 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12525 byte *arg2 = (byte *) 0 ;
12526 byte *arg3 = (byte *) 0 ;
12527 byte *arg4 = (byte *) 0 ;
12528 byte arg5 = (byte) 1 ;
12529 byte arg6 = (byte) 0 ;
12530 byte arg7 = (byte) 0 ;
12531 bool result;
12532 void *argp1 = 0 ;
12533 int res1 = 0 ;
12534 byte temp2 ;
12535 int res2 = SWIG_TMPOBJ ;
12536 byte temp3 ;
12537 int res3 = SWIG_TMPOBJ ;
12538 byte temp4 ;
12539 int res4 = SWIG_TMPOBJ ;
12540 unsigned char val5 ;
12541 int ecode5 = 0 ;
12542 unsigned char val6 ;
12543 int ecode6 = 0 ;
12544 unsigned char val7 ;
12545 int ecode7 = 0 ;
12546 PyObject * obj0 = 0 ;
12547 PyObject * obj1 = 0 ;
12548 PyObject * obj2 = 0 ;
12549 PyObject * obj3 = 0 ;
12550 char * kwnames[] = {
12551 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12552 };
12553
12554 arg2 = &temp2;
12555 arg3 = &temp3;
12556 arg4 = &temp4;
12557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12559 if (!SWIG_IsOK(res1)) {
12560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12561 }
12562 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12563 if (obj1) {
12564 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12565 if (!SWIG_IsOK(ecode5)) {
12566 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12567 }
12568 arg5 = static_cast< byte >(val5);
12569 }
12570 if (obj2) {
12571 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12572 if (!SWIG_IsOK(ecode6)) {
12573 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12574 }
12575 arg6 = static_cast< byte >(val6);
12576 }
12577 if (obj3) {
12578 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12579 if (!SWIG_IsOK(ecode7)) {
12580 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12581 }
12582 arg7 = static_cast< byte >(val7);
12583 }
12584 {
12585 PyThreadState* __tstate = wxPyBeginAllowThreads();
12586 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12587 wxPyEndAllowThreads(__tstate);
12588 if (PyErr_Occurred()) SWIG_fail;
12589 }
12590 {
12591 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12592 }
12593 if (SWIG_IsTmpObj(res2)) {
12594 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12595 } else {
12596 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12597 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12598 }
12599 if (SWIG_IsTmpObj(res3)) {
12600 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12601 } else {
12602 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12603 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12604 }
12605 if (SWIG_IsTmpObj(res4)) {
12606 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12607 } else {
12608 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12609 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12610 }
12611 return resultobj;
12612 fail:
12613 return NULL;
12614 }
12615
12616
12617 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12618 PyObject *resultobj = 0;
12619 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12620 unsigned long arg2 ;
12621 unsigned long result;
12622 void *argp1 = 0 ;
12623 int res1 = 0 ;
12624 unsigned long val2 ;
12625 int ecode2 = 0 ;
12626 PyObject * obj0 = 0 ;
12627 PyObject * obj1 = 0 ;
12628 char * kwnames[] = {
12629 (char *) "self",(char *) "key", NULL
12630 };
12631
12632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12634 if (!SWIG_IsOK(res1)) {
12635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12636 }
12637 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12638 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12639 if (!SWIG_IsOK(ecode2)) {
12640 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12641 }
12642 arg2 = static_cast< unsigned long >(val2);
12643 {
12644 PyThreadState* __tstate = wxPyBeginAllowThreads();
12645 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12646 wxPyEndAllowThreads(__tstate);
12647 if (PyErr_Occurred()) SWIG_fail;
12648 }
12649 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12650 return resultobj;
12651 fail:
12652 return NULL;
12653 }
12654
12655
12656 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12657 PyObject *resultobj = 0;
12658 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12659 byte arg2 ;
12660 byte arg3 ;
12661 byte arg4 ;
12662 unsigned long result;
12663 void *argp1 = 0 ;
12664 int res1 = 0 ;
12665 unsigned char val2 ;
12666 int ecode2 = 0 ;
12667 unsigned char val3 ;
12668 int ecode3 = 0 ;
12669 unsigned char val4 ;
12670 int ecode4 = 0 ;
12671 PyObject * obj0 = 0 ;
12672 PyObject * obj1 = 0 ;
12673 PyObject * obj2 = 0 ;
12674 PyObject * obj3 = 0 ;
12675 char * kwnames[] = {
12676 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12677 };
12678
12679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12681 if (!SWIG_IsOK(res1)) {
12682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12683 }
12684 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12685 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12686 if (!SWIG_IsOK(ecode2)) {
12687 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12688 }
12689 arg2 = static_cast< byte >(val2);
12690 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12691 if (!SWIG_IsOK(ecode3)) {
12692 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12693 }
12694 arg3 = static_cast< byte >(val3);
12695 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12696 if (!SWIG_IsOK(ecode4)) {
12697 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12698 }
12699 arg4 = static_cast< byte >(val4);
12700 {
12701 PyThreadState* __tstate = wxPyBeginAllowThreads();
12702 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12703 wxPyEndAllowThreads(__tstate);
12704 if (PyErr_Occurred()) SWIG_fail;
12705 }
12706 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12707 return resultobj;
12708 fail:
12709 return NULL;
12710 }
12711
12712
12713 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12714 PyObject *resultobj = 0;
12715 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12716 wxColour *arg2 = 0 ;
12717 unsigned long result;
12718 void *argp1 = 0 ;
12719 int res1 = 0 ;
12720 wxColour temp2 ;
12721 PyObject * obj0 = 0 ;
12722 PyObject * obj1 = 0 ;
12723 char * kwnames[] = {
12724 (char *) "self",(char *) "colour", NULL
12725 };
12726
12727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12729 if (!SWIG_IsOK(res1)) {
12730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12731 }
12732 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12733 {
12734 arg2 = &temp2;
12735 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12736 }
12737 {
12738 PyThreadState* __tstate = wxPyBeginAllowThreads();
12739 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12740 wxPyEndAllowThreads(__tstate);
12741 if (PyErr_Occurred()) SWIG_fail;
12742 }
12743 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12744 return resultobj;
12745 fail:
12746 return NULL;
12747 }
12748
12749
12750 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12751 PyObject *obj;
12752 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12753 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12754 return SWIG_Py_Void();
12755 }
12756
12757 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12758 return SWIG_Python_InitShadowInstance(args);
12759 }
12760
12761 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12762 PyObject *resultobj = 0;
12763 byte arg1 = (byte) 0 ;
12764 byte arg2 = (byte) 0 ;
12765 byte arg3 = (byte) 0 ;
12766 wxImage_RGBValue *result = 0 ;
12767 unsigned char val1 ;
12768 int ecode1 = 0 ;
12769 unsigned char val2 ;
12770 int ecode2 = 0 ;
12771 unsigned char val3 ;
12772 int ecode3 = 0 ;
12773 PyObject * obj0 = 0 ;
12774 PyObject * obj1 = 0 ;
12775 PyObject * obj2 = 0 ;
12776 char * kwnames[] = {
12777 (char *) "r",(char *) "g",(char *) "b", NULL
12778 };
12779
12780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12781 if (obj0) {
12782 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12783 if (!SWIG_IsOK(ecode1)) {
12784 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12785 }
12786 arg1 = static_cast< byte >(val1);
12787 }
12788 if (obj1) {
12789 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12790 if (!SWIG_IsOK(ecode2)) {
12791 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12792 }
12793 arg2 = static_cast< byte >(val2);
12794 }
12795 if (obj2) {
12796 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12797 if (!SWIG_IsOK(ecode3)) {
12798 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12799 }
12800 arg3 = static_cast< byte >(val3);
12801 }
12802 {
12803 PyThreadState* __tstate = wxPyBeginAllowThreads();
12804 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12805 wxPyEndAllowThreads(__tstate);
12806 if (PyErr_Occurred()) SWIG_fail;
12807 }
12808 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12809 return resultobj;
12810 fail:
12811 return NULL;
12812 }
12813
12814
12815 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12816 PyObject *resultobj = 0;
12817 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12818 byte arg2 ;
12819 void *argp1 = 0 ;
12820 int res1 = 0 ;
12821 unsigned char val2 ;
12822 int ecode2 = 0 ;
12823 PyObject *swig_obj[2] ;
12824
12825 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12827 if (!SWIG_IsOK(res1)) {
12828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12829 }
12830 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12831 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12832 if (!SWIG_IsOK(ecode2)) {
12833 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12834 }
12835 arg2 = static_cast< byte >(val2);
12836 if (arg1) (arg1)->red = arg2;
12837
12838 resultobj = SWIG_Py_Void();
12839 return resultobj;
12840 fail:
12841 return NULL;
12842 }
12843
12844
12845 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12846 PyObject *resultobj = 0;
12847 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12848 byte result;
12849 void *argp1 = 0 ;
12850 int res1 = 0 ;
12851 PyObject *swig_obj[1] ;
12852
12853 if (!args) SWIG_fail;
12854 swig_obj[0] = args;
12855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12856 if (!SWIG_IsOK(res1)) {
12857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12858 }
12859 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12860 result = (byte) ((arg1)->red);
12861 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12862 return resultobj;
12863 fail:
12864 return NULL;
12865 }
12866
12867
12868 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12869 PyObject *resultobj = 0;
12870 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12871 byte arg2 ;
12872 void *argp1 = 0 ;
12873 int res1 = 0 ;
12874 unsigned char val2 ;
12875 int ecode2 = 0 ;
12876 PyObject *swig_obj[2] ;
12877
12878 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12880 if (!SWIG_IsOK(res1)) {
12881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12882 }
12883 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12884 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12885 if (!SWIG_IsOK(ecode2)) {
12886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12887 }
12888 arg2 = static_cast< byte >(val2);
12889 if (arg1) (arg1)->green = arg2;
12890
12891 resultobj = SWIG_Py_Void();
12892 return resultobj;
12893 fail:
12894 return NULL;
12895 }
12896
12897
12898 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12899 PyObject *resultobj = 0;
12900 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12901 byte result;
12902 void *argp1 = 0 ;
12903 int res1 = 0 ;
12904 PyObject *swig_obj[1] ;
12905
12906 if (!args) SWIG_fail;
12907 swig_obj[0] = args;
12908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12909 if (!SWIG_IsOK(res1)) {
12910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12911 }
12912 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12913 result = (byte) ((arg1)->green);
12914 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12915 return resultobj;
12916 fail:
12917 return NULL;
12918 }
12919
12920
12921 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12922 PyObject *resultobj = 0;
12923 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12924 byte arg2 ;
12925 void *argp1 = 0 ;
12926 int res1 = 0 ;
12927 unsigned char val2 ;
12928 int ecode2 = 0 ;
12929 PyObject *swig_obj[2] ;
12930
12931 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
12932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12933 if (!SWIG_IsOK(res1)) {
12934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12935 }
12936 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12937 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12938 if (!SWIG_IsOK(ecode2)) {
12939 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
12940 }
12941 arg2 = static_cast< byte >(val2);
12942 if (arg1) (arg1)->blue = arg2;
12943
12944 resultobj = SWIG_Py_Void();
12945 return resultobj;
12946 fail:
12947 return NULL;
12948 }
12949
12950
12951 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12952 PyObject *resultobj = 0;
12953 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12954 byte result;
12955 void *argp1 = 0 ;
12956 int res1 = 0 ;
12957 PyObject *swig_obj[1] ;
12958
12959 if (!args) SWIG_fail;
12960 swig_obj[0] = args;
12961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12962 if (!SWIG_IsOK(res1)) {
12963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12964 }
12965 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12966 result = (byte) ((arg1)->blue);
12967 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12968 return resultobj;
12969 fail:
12970 return NULL;
12971 }
12972
12973
12974 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12975 PyObject *obj;
12976 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12977 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
12978 return SWIG_Py_Void();
12979 }
12980
12981 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12982 return SWIG_Python_InitShadowInstance(args);
12983 }
12984
12985 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12986 PyObject *resultobj = 0;
12987 double arg1 = (double) 0.0 ;
12988 double arg2 = (double) 0.0 ;
12989 double arg3 = (double) 0.0 ;
12990 wxImage_HSVValue *result = 0 ;
12991 double val1 ;
12992 int ecode1 = 0 ;
12993 double val2 ;
12994 int ecode2 = 0 ;
12995 double val3 ;
12996 int ecode3 = 0 ;
12997 PyObject * obj0 = 0 ;
12998 PyObject * obj1 = 0 ;
12999 PyObject * obj2 = 0 ;
13000 char * kwnames[] = {
13001 (char *) "h",(char *) "s",(char *) "v", NULL
13002 };
13003
13004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13005 if (obj0) {
13006 ecode1 = SWIG_AsVal_double(obj0, &val1);
13007 if (!SWIG_IsOK(ecode1)) {
13008 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
13009 }
13010 arg1 = static_cast< double >(val1);
13011 }
13012 if (obj1) {
13013 ecode2 = SWIG_AsVal_double(obj1, &val2);
13014 if (!SWIG_IsOK(ecode2)) {
13015 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
13016 }
13017 arg2 = static_cast< double >(val2);
13018 }
13019 if (obj2) {
13020 ecode3 = SWIG_AsVal_double(obj2, &val3);
13021 if (!SWIG_IsOK(ecode3)) {
13022 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
13023 }
13024 arg3 = static_cast< double >(val3);
13025 }
13026 {
13027 PyThreadState* __tstate = wxPyBeginAllowThreads();
13028 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
13029 wxPyEndAllowThreads(__tstate);
13030 if (PyErr_Occurred()) SWIG_fail;
13031 }
13032 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
13033 return resultobj;
13034 fail:
13035 return NULL;
13036 }
13037
13038
13039 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13040 PyObject *resultobj = 0;
13041 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13042 double arg2 ;
13043 void *argp1 = 0 ;
13044 int res1 = 0 ;
13045 double val2 ;
13046 int ecode2 = 0 ;
13047 PyObject *swig_obj[2] ;
13048
13049 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
13050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13051 if (!SWIG_IsOK(res1)) {
13052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13053 }
13054 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13055 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13056 if (!SWIG_IsOK(ecode2)) {
13057 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
13058 }
13059 arg2 = static_cast< double >(val2);
13060 if (arg1) (arg1)->hue = arg2;
13061
13062 resultobj = SWIG_Py_Void();
13063 return resultobj;
13064 fail:
13065 return NULL;
13066 }
13067
13068
13069 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13070 PyObject *resultobj = 0;
13071 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13072 double result;
13073 void *argp1 = 0 ;
13074 int res1 = 0 ;
13075 PyObject *swig_obj[1] ;
13076
13077 if (!args) SWIG_fail;
13078 swig_obj[0] = args;
13079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13080 if (!SWIG_IsOK(res1)) {
13081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13082 }
13083 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13084 result = (double) ((arg1)->hue);
13085 resultobj = SWIG_From_double(static_cast< double >(result));
13086 return resultobj;
13087 fail:
13088 return NULL;
13089 }
13090
13091
13092 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13093 PyObject *resultobj = 0;
13094 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13095 double arg2 ;
13096 void *argp1 = 0 ;
13097 int res1 = 0 ;
13098 double val2 ;
13099 int ecode2 = 0 ;
13100 PyObject *swig_obj[2] ;
13101
13102 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
13103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13104 if (!SWIG_IsOK(res1)) {
13105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13106 }
13107 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13108 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13109 if (!SWIG_IsOK(ecode2)) {
13110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
13111 }
13112 arg2 = static_cast< double >(val2);
13113 if (arg1) (arg1)->saturation = arg2;
13114
13115 resultobj = SWIG_Py_Void();
13116 return resultobj;
13117 fail:
13118 return NULL;
13119 }
13120
13121
13122 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13123 PyObject *resultobj = 0;
13124 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13125 double result;
13126 void *argp1 = 0 ;
13127 int res1 = 0 ;
13128 PyObject *swig_obj[1] ;
13129
13130 if (!args) SWIG_fail;
13131 swig_obj[0] = args;
13132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13133 if (!SWIG_IsOK(res1)) {
13134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13135 }
13136 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13137 result = (double) ((arg1)->saturation);
13138 resultobj = SWIG_From_double(static_cast< double >(result));
13139 return resultobj;
13140 fail:
13141 return NULL;
13142 }
13143
13144
13145 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13146 PyObject *resultobj = 0;
13147 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13148 double arg2 ;
13149 void *argp1 = 0 ;
13150 int res1 = 0 ;
13151 double val2 ;
13152 int ecode2 = 0 ;
13153 PyObject *swig_obj[2] ;
13154
13155 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
13156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13157 if (!SWIG_IsOK(res1)) {
13158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13159 }
13160 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13161 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13162 if (!SWIG_IsOK(ecode2)) {
13163 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
13164 }
13165 arg2 = static_cast< double >(val2);
13166 if (arg1) (arg1)->value = arg2;
13167
13168 resultobj = SWIG_Py_Void();
13169 return resultobj;
13170 fail:
13171 return NULL;
13172 }
13173
13174
13175 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13176 PyObject *resultobj = 0;
13177 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13178 double result;
13179 void *argp1 = 0 ;
13180 int res1 = 0 ;
13181 PyObject *swig_obj[1] ;
13182
13183 if (!args) SWIG_fail;
13184 swig_obj[0] = args;
13185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13186 if (!SWIG_IsOK(res1)) {
13187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13188 }
13189 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13190 result = (double) ((arg1)->value);
13191 resultobj = SWIG_From_double(static_cast< double >(result));
13192 return resultobj;
13193 fail:
13194 return NULL;
13195 }
13196
13197
13198 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13199 PyObject *obj;
13200 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13201 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
13202 return SWIG_Py_Void();
13203 }
13204
13205 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13206 return SWIG_Python_InitShadowInstance(args);
13207 }
13208
13209 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13210 PyObject *resultobj = 0;
13211 wxString *arg1 = 0 ;
13212 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13213 int arg3 = (int) -1 ;
13214 wxImage *result = 0 ;
13215 bool temp1 = false ;
13216 long val2 ;
13217 int ecode2 = 0 ;
13218 int val3 ;
13219 int ecode3 = 0 ;
13220 PyObject * obj0 = 0 ;
13221 PyObject * obj1 = 0 ;
13222 PyObject * obj2 = 0 ;
13223 char * kwnames[] = {
13224 (char *) "name",(char *) "type",(char *) "index", NULL
13225 };
13226
13227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13228 {
13229 arg1 = wxString_in_helper(obj0);
13230 if (arg1 == NULL) SWIG_fail;
13231 temp1 = true;
13232 }
13233 if (obj1) {
13234 ecode2 = SWIG_AsVal_long(obj1, &val2);
13235 if (!SWIG_IsOK(ecode2)) {
13236 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
13237 }
13238 arg2 = static_cast< long >(val2);
13239 }
13240 if (obj2) {
13241 ecode3 = SWIG_AsVal_int(obj2, &val3);
13242 if (!SWIG_IsOK(ecode3)) {
13243 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
13244 }
13245 arg3 = static_cast< int >(val3);
13246 }
13247 {
13248 PyThreadState* __tstate = wxPyBeginAllowThreads();
13249 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
13250 wxPyEndAllowThreads(__tstate);
13251 if (PyErr_Occurred()) SWIG_fail;
13252 }
13253 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
13254 {
13255 if (temp1)
13256 delete arg1;
13257 }
13258 return resultobj;
13259 fail:
13260 {
13261 if (temp1)
13262 delete arg1;
13263 }
13264 return NULL;
13265 }
13266
13267
13268 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13269 PyObject *resultobj = 0;
13270 wxImage *arg1 = (wxImage *) 0 ;
13271 void *argp1 = 0 ;
13272 int res1 = 0 ;
13273 PyObject *swig_obj[1] ;
13274
13275 if (!args) SWIG_fail;
13276 swig_obj[0] = args;
13277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
13278 if (!SWIG_IsOK(res1)) {
13279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
13280 }
13281 arg1 = reinterpret_cast< wxImage * >(argp1);
13282 {
13283 PyThreadState* __tstate = wxPyBeginAllowThreads();
13284 delete arg1;
13285
13286 wxPyEndAllowThreads(__tstate);
13287 if (PyErr_Occurred()) SWIG_fail;
13288 }
13289 resultobj = SWIG_Py_Void();
13290 return resultobj;
13291 fail:
13292 return NULL;
13293 }
13294
13295
13296 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13297 PyObject *resultobj = 0;
13298 wxString *arg1 = 0 ;
13299 wxString *arg2 = 0 ;
13300 int arg3 = (int) -1 ;
13301 wxImage *result = 0 ;
13302 bool temp1 = false ;
13303 bool temp2 = false ;
13304 int val3 ;
13305 int ecode3 = 0 ;
13306 PyObject * obj0 = 0 ;
13307 PyObject * obj1 = 0 ;
13308 PyObject * obj2 = 0 ;
13309 char * kwnames[] = {
13310 (char *) "name",(char *) "mimetype",(char *) "index", NULL
13311 };
13312
13313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13314 {
13315 arg1 = wxString_in_helper(obj0);
13316 if (arg1 == NULL) SWIG_fail;
13317 temp1 = true;
13318 }
13319 {
13320 arg2 = wxString_in_helper(obj1);
13321 if (arg2 == NULL) SWIG_fail;
13322 temp2 = true;
13323 }
13324 if (obj2) {
13325 ecode3 = SWIG_AsVal_int(obj2, &val3);
13326 if (!SWIG_IsOK(ecode3)) {
13327 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
13328 }
13329 arg3 = static_cast< int >(val3);
13330 }
13331 {
13332 PyThreadState* __tstate = wxPyBeginAllowThreads();
13333 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
13334 wxPyEndAllowThreads(__tstate);
13335 if (PyErr_Occurred()) SWIG_fail;
13336 }
13337 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13338 {
13339 if (temp1)
13340 delete arg1;
13341 }
13342 {
13343 if (temp2)
13344 delete arg2;
13345 }
13346 return resultobj;
13347 fail:
13348 {
13349 if (temp1)
13350 delete arg1;
13351 }
13352 {
13353 if (temp2)
13354 delete arg2;
13355 }
13356 return NULL;
13357 }
13358
13359
13360 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13361 PyObject *resultobj = 0;
13362 wxInputStream *arg1 = 0 ;
13363 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13364 int arg3 = (int) -1 ;
13365 wxImage *result = 0 ;
13366 wxPyInputStream *temp1 ;
13367 bool created1 ;
13368 long val2 ;
13369 int ecode2 = 0 ;
13370 int val3 ;
13371 int ecode3 = 0 ;
13372 PyObject * obj0 = 0 ;
13373 PyObject * obj1 = 0 ;
13374 PyObject * obj2 = 0 ;
13375 char * kwnames[] = {
13376 (char *) "stream",(char *) "type",(char *) "index", NULL
13377 };
13378
13379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13380 {
13381 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13382 arg1 = temp1->m_wxis;
13383 created1 = false;
13384 } else {
13385 PyErr_Clear(); // clear the failure of the wxPyConvert above
13386 arg1 = wxPyCBInputStream_create(obj0, false);
13387 if (arg1 == NULL) {
13388 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13389 SWIG_fail;
13390 }
13391 created1 = true;
13392 }
13393 }
13394 if (obj1) {
13395 ecode2 = SWIG_AsVal_long(obj1, &val2);
13396 if (!SWIG_IsOK(ecode2)) {
13397 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13398 }
13399 arg2 = static_cast< long >(val2);
13400 }
13401 if (obj2) {
13402 ecode3 = SWIG_AsVal_int(obj2, &val3);
13403 if (!SWIG_IsOK(ecode3)) {
13404 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13405 }
13406 arg3 = static_cast< int >(val3);
13407 }
13408 {
13409 PyThreadState* __tstate = wxPyBeginAllowThreads();
13410 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13411 wxPyEndAllowThreads(__tstate);
13412 if (PyErr_Occurred()) SWIG_fail;
13413 }
13414 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13415 {
13416 if (created1) delete arg1;
13417 }
13418 return resultobj;
13419 fail:
13420 {
13421 if (created1) delete arg1;
13422 }
13423 return NULL;
13424 }
13425
13426
13427 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13428 PyObject *resultobj = 0;
13429 wxInputStream *arg1 = 0 ;
13430 wxString *arg2 = 0 ;
13431 int arg3 = (int) -1 ;
13432 wxImage *result = 0 ;
13433 wxPyInputStream *temp1 ;
13434 bool created1 ;
13435 bool temp2 = false ;
13436 int val3 ;
13437 int ecode3 = 0 ;
13438 PyObject * obj0 = 0 ;
13439 PyObject * obj1 = 0 ;
13440 PyObject * obj2 = 0 ;
13441 char * kwnames[] = {
13442 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13443 };
13444
13445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13446 {
13447 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13448 arg1 = temp1->m_wxis;
13449 created1 = false;
13450 } else {
13451 PyErr_Clear(); // clear the failure of the wxPyConvert above
13452 arg1 = wxPyCBInputStream_create(obj0, false);
13453 if (arg1 == NULL) {
13454 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13455 SWIG_fail;
13456 }
13457 created1 = true;
13458 }
13459 }
13460 {
13461 arg2 = wxString_in_helper(obj1);
13462 if (arg2 == NULL) SWIG_fail;
13463 temp2 = true;
13464 }
13465 if (obj2) {
13466 ecode3 = SWIG_AsVal_int(obj2, &val3);
13467 if (!SWIG_IsOK(ecode3)) {
13468 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13469 }
13470 arg3 = static_cast< int >(val3);
13471 }
13472 {
13473 PyThreadState* __tstate = wxPyBeginAllowThreads();
13474 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13475 wxPyEndAllowThreads(__tstate);
13476 if (PyErr_Occurred()) SWIG_fail;
13477 }
13478 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13479 {
13480 if (created1) delete arg1;
13481 }
13482 {
13483 if (temp2)
13484 delete arg2;
13485 }
13486 return resultobj;
13487 fail:
13488 {
13489 if (created1) delete arg1;
13490 }
13491 {
13492 if (temp2)
13493 delete arg2;
13494 }
13495 return NULL;
13496 }
13497
13498
13499 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13500 PyObject *resultobj = 0;
13501 int arg1 = (int) 0 ;
13502 int arg2 = (int) 0 ;
13503 bool arg3 = (bool) true ;
13504 wxImage *result = 0 ;
13505 int val1 ;
13506 int ecode1 = 0 ;
13507 int val2 ;
13508 int ecode2 = 0 ;
13509 bool val3 ;
13510 int ecode3 = 0 ;
13511 PyObject * obj0 = 0 ;
13512 PyObject * obj1 = 0 ;
13513 PyObject * obj2 = 0 ;
13514 char * kwnames[] = {
13515 (char *) "width",(char *) "height",(char *) "clear", NULL
13516 };
13517
13518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13519 if (obj0) {
13520 ecode1 = SWIG_AsVal_int(obj0, &val1);
13521 if (!SWIG_IsOK(ecode1)) {
13522 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13523 }
13524 arg1 = static_cast< int >(val1);
13525 }
13526 if (obj1) {
13527 ecode2 = SWIG_AsVal_int(obj1, &val2);
13528 if (!SWIG_IsOK(ecode2)) {
13529 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13530 }
13531 arg2 = static_cast< int >(val2);
13532 }
13533 if (obj2) {
13534 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13535 if (!SWIG_IsOK(ecode3)) {
13536 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13537 }
13538 arg3 = static_cast< bool >(val3);
13539 }
13540 {
13541 PyThreadState* __tstate = wxPyBeginAllowThreads();
13542 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13543 wxPyEndAllowThreads(__tstate);
13544 if (PyErr_Occurred()) SWIG_fail;
13545 }
13546 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13547 return resultobj;
13548 fail:
13549 return NULL;
13550 }
13551
13552
13553 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13554 PyObject *resultobj = 0;
13555 wxBitmap *arg1 = 0 ;
13556 wxImage *result = 0 ;
13557 void *argp1 = 0 ;
13558 int res1 = 0 ;
13559 PyObject * obj0 = 0 ;
13560 char * kwnames[] = {
13561 (char *) "bitmap", NULL
13562 };
13563
13564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13565 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13566 if (!SWIG_IsOK(res1)) {
13567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13568 }
13569 if (!argp1) {
13570 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13571 }
13572 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13573 {
13574 if (!wxPyCheckForApp()) SWIG_fail;
13575 PyThreadState* __tstate = wxPyBeginAllowThreads();
13576 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13577 wxPyEndAllowThreads(__tstate);
13578 if (PyErr_Occurred()) SWIG_fail;
13579 }
13580 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13581 return resultobj;
13582 fail:
13583 return NULL;
13584 }
13585
13586
13587 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13588 PyObject *resultobj = 0;
13589 int arg1 ;
13590 int arg2 ;
13591 buffer arg3 ;
13592 int arg4 ;
13593 wxImage *result = 0 ;
13594 int val1 ;
13595 int ecode1 = 0 ;
13596 int val2 ;
13597 int ecode2 = 0 ;
13598 Py_ssize_t temp3 ;
13599 PyObject * obj0 = 0 ;
13600 PyObject * obj1 = 0 ;
13601 PyObject * obj2 = 0 ;
13602 char * kwnames[] = {
13603 (char *) "width",(char *) "height",(char *) "data", NULL
13604 };
13605
13606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13607 ecode1 = SWIG_AsVal_int(obj0, &val1);
13608 if (!SWIG_IsOK(ecode1)) {
13609 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13610 }
13611 arg1 = static_cast< int >(val1);
13612 ecode2 = SWIG_AsVal_int(obj1, &val2);
13613 if (!SWIG_IsOK(ecode2)) {
13614 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13615 }
13616 arg2 = static_cast< int >(val2);
13617 {
13618 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
13619 arg4 = (int)temp3;
13620 }
13621 {
13622 PyThreadState* __tstate = wxPyBeginAllowThreads();
13623 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13624 wxPyEndAllowThreads(__tstate);
13625 if (PyErr_Occurred()) SWIG_fail;
13626 }
13627 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13628 return resultobj;
13629 fail:
13630 return NULL;
13631 }
13632
13633
13634 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13635 PyObject *resultobj = 0;
13636 int arg1 ;
13637 int arg2 ;
13638 buffer arg3 ;
13639 int arg4 ;
13640 buffer arg5 ;
13641 int arg6 ;
13642 wxImage *result = 0 ;
13643 int val1 ;
13644 int ecode1 = 0 ;
13645 int val2 ;
13646 int ecode2 = 0 ;
13647 Py_ssize_t temp3 ;
13648 Py_ssize_t temp5 ;
13649 PyObject * obj0 = 0 ;
13650 PyObject * obj1 = 0 ;
13651 PyObject * obj2 = 0 ;
13652 PyObject * obj3 = 0 ;
13653 char * kwnames[] = {
13654 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13655 };
13656
13657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13658 ecode1 = SWIG_AsVal_int(obj0, &val1);
13659 if (!SWIG_IsOK(ecode1)) {
13660 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13661 }
13662 arg1 = static_cast< int >(val1);
13663 ecode2 = SWIG_AsVal_int(obj1, &val2);
13664 if (!SWIG_IsOK(ecode2)) {
13665 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13666 }
13667 arg2 = static_cast< int >(val2);
13668 {
13669 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
13670 arg4 = (int)temp3;
13671 }
13672 {
13673 if (obj3 != Py_None) {
13674 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
13675 arg6 = (int)temp5;
13676 }
13677 }
13678 {
13679 PyThreadState* __tstate = wxPyBeginAllowThreads();
13680 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13681 wxPyEndAllowThreads(__tstate);
13682 if (PyErr_Occurred()) SWIG_fail;
13683 }
13684 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13685 return resultobj;
13686 fail:
13687 return NULL;
13688 }
13689
13690
13691 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13692 PyObject *resultobj = 0;
13693 wxImage *arg1 = (wxImage *) 0 ;
13694 int arg2 ;
13695 int arg3 ;
13696 bool arg4 = (bool) true ;
13697 void *argp1 = 0 ;
13698 int res1 = 0 ;
13699 int val2 ;
13700 int ecode2 = 0 ;
13701 int val3 ;
13702 int ecode3 = 0 ;
13703 bool val4 ;
13704 int ecode4 = 0 ;
13705 PyObject * obj0 = 0 ;
13706 PyObject * obj1 = 0 ;
13707 PyObject * obj2 = 0 ;
13708 PyObject * obj3 = 0 ;
13709 char * kwnames[] = {
13710 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13711 };
13712
13713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13715 if (!SWIG_IsOK(res1)) {
13716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13717 }
13718 arg1 = reinterpret_cast< wxImage * >(argp1);
13719 ecode2 = SWIG_AsVal_int(obj1, &val2);
13720 if (!SWIG_IsOK(ecode2)) {
13721 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13722 }
13723 arg2 = static_cast< int >(val2);
13724 ecode3 = SWIG_AsVal_int(obj2, &val3);
13725 if (!SWIG_IsOK(ecode3)) {
13726 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13727 }
13728 arg3 = static_cast< int >(val3);
13729 if (obj3) {
13730 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13731 if (!SWIG_IsOK(ecode4)) {
13732 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13733 }
13734 arg4 = static_cast< bool >(val4);
13735 }
13736 {
13737 PyThreadState* __tstate = wxPyBeginAllowThreads();
13738 (arg1)->Create(arg2,arg3,arg4);
13739 wxPyEndAllowThreads(__tstate);
13740 if (PyErr_Occurred()) SWIG_fail;
13741 }
13742 resultobj = SWIG_Py_Void();
13743 return resultobj;
13744 fail:
13745 return NULL;
13746 }
13747
13748
13749 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13750 PyObject *resultobj = 0;
13751 wxImage *arg1 = (wxImage *) 0 ;
13752 void *argp1 = 0 ;
13753 int res1 = 0 ;
13754 PyObject *swig_obj[1] ;
13755
13756 if (!args) SWIG_fail;
13757 swig_obj[0] = args;
13758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13759 if (!SWIG_IsOK(res1)) {
13760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13761 }
13762 arg1 = reinterpret_cast< wxImage * >(argp1);
13763 {
13764 PyThreadState* __tstate = wxPyBeginAllowThreads();
13765 (arg1)->Destroy();
13766 wxPyEndAllowThreads(__tstate);
13767 if (PyErr_Occurred()) SWIG_fail;
13768 }
13769 resultobj = SWIG_Py_Void();
13770 return resultobj;
13771 fail:
13772 return NULL;
13773 }
13774
13775
13776 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13777 PyObject *resultobj = 0;
13778 wxImage *arg1 = (wxImage *) 0 ;
13779 int arg2 ;
13780 int arg3 ;
13781 SwigValueWrapper<wxImage > result;
13782 void *argp1 = 0 ;
13783 int res1 = 0 ;
13784 int val2 ;
13785 int ecode2 = 0 ;
13786 int val3 ;
13787 int ecode3 = 0 ;
13788 PyObject * obj0 = 0 ;
13789 PyObject * obj1 = 0 ;
13790 PyObject * obj2 = 0 ;
13791 char * kwnames[] = {
13792 (char *) "self",(char *) "width",(char *) "height", NULL
13793 };
13794
13795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13797 if (!SWIG_IsOK(res1)) {
13798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13799 }
13800 arg1 = reinterpret_cast< wxImage * >(argp1);
13801 ecode2 = SWIG_AsVal_int(obj1, &val2);
13802 if (!SWIG_IsOK(ecode2)) {
13803 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13804 }
13805 arg2 = static_cast< int >(val2);
13806 ecode3 = SWIG_AsVal_int(obj2, &val3);
13807 if (!SWIG_IsOK(ecode3)) {
13808 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13809 }
13810 arg3 = static_cast< int >(val3);
13811 {
13812 PyThreadState* __tstate = wxPyBeginAllowThreads();
13813 result = (arg1)->Scale(arg2,arg3);
13814 wxPyEndAllowThreads(__tstate);
13815 if (PyErr_Occurred()) SWIG_fail;
13816 }
13817 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13818 return resultobj;
13819 fail:
13820 return NULL;
13821 }
13822
13823
13824 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13825 PyObject *resultobj = 0;
13826 wxImage *arg1 = (wxImage *) 0 ;
13827 int arg2 ;
13828 int arg3 ;
13829 SwigValueWrapper<wxImage > result;
13830 void *argp1 = 0 ;
13831 int res1 = 0 ;
13832 int val2 ;
13833 int ecode2 = 0 ;
13834 int val3 ;
13835 int ecode3 = 0 ;
13836 PyObject * obj0 = 0 ;
13837 PyObject * obj1 = 0 ;
13838 PyObject * obj2 = 0 ;
13839 char * kwnames[] = {
13840 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
13841 };
13842
13843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13845 if (!SWIG_IsOK(res1)) {
13846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
13847 }
13848 arg1 = reinterpret_cast< wxImage * >(argp1);
13849 ecode2 = SWIG_AsVal_int(obj1, &val2);
13850 if (!SWIG_IsOK(ecode2)) {
13851 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
13852 }
13853 arg2 = static_cast< int >(val2);
13854 ecode3 = SWIG_AsVal_int(obj2, &val3);
13855 if (!SWIG_IsOK(ecode3)) {
13856 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
13857 }
13858 arg3 = static_cast< int >(val3);
13859 {
13860 PyThreadState* __tstate = wxPyBeginAllowThreads();
13861 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
13862 wxPyEndAllowThreads(__tstate);
13863 if (PyErr_Occurred()) SWIG_fail;
13864 }
13865 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13866 return resultobj;
13867 fail:
13868 return NULL;
13869 }
13870
13871
13872 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13873 PyObject *resultobj = 0;
13874 wxImage *arg1 = (wxImage *) 0 ;
13875 int arg2 ;
13876 int arg3 ;
13877 wxImage *result = 0 ;
13878 void *argp1 = 0 ;
13879 int res1 = 0 ;
13880 int val2 ;
13881 int ecode2 = 0 ;
13882 int val3 ;
13883 int ecode3 = 0 ;
13884 PyObject * obj0 = 0 ;
13885 PyObject * obj1 = 0 ;
13886 PyObject * obj2 = 0 ;
13887 char * kwnames[] = {
13888 (char *) "self",(char *) "width",(char *) "height", NULL
13889 };
13890
13891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13893 if (!SWIG_IsOK(res1)) {
13894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
13895 }
13896 arg1 = reinterpret_cast< wxImage * >(argp1);
13897 ecode2 = SWIG_AsVal_int(obj1, &val2);
13898 if (!SWIG_IsOK(ecode2)) {
13899 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
13900 }
13901 arg2 = static_cast< int >(val2);
13902 ecode3 = SWIG_AsVal_int(obj2, &val3);
13903 if (!SWIG_IsOK(ecode3)) {
13904 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
13905 }
13906 arg3 = static_cast< int >(val3);
13907 {
13908 PyThreadState* __tstate = wxPyBeginAllowThreads();
13909 {
13910 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
13911 result = (wxImage *) &_result_ref;
13912 }
13913 wxPyEndAllowThreads(__tstate);
13914 if (PyErr_Occurred()) SWIG_fail;
13915 }
13916 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13917 return resultobj;
13918 fail:
13919 return NULL;
13920 }
13921
13922
13923 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13924 PyObject *resultobj = 0;
13925 wxImage *arg1 = (wxImage *) 0 ;
13926 wxSize *arg2 = 0 ;
13927 wxPoint *arg3 = 0 ;
13928 int arg4 = (int) -1 ;
13929 int arg5 = (int) -1 ;
13930 int arg6 = (int) -1 ;
13931 wxImage *result = 0 ;
13932 void *argp1 = 0 ;
13933 int res1 = 0 ;
13934 wxSize temp2 ;
13935 wxPoint temp3 ;
13936 int val4 ;
13937 int ecode4 = 0 ;
13938 int val5 ;
13939 int ecode5 = 0 ;
13940 int val6 ;
13941 int ecode6 = 0 ;
13942 PyObject * obj0 = 0 ;
13943 PyObject * obj1 = 0 ;
13944 PyObject * obj2 = 0 ;
13945 PyObject * obj3 = 0 ;
13946 PyObject * obj4 = 0 ;
13947 PyObject * obj5 = 0 ;
13948 char * kwnames[] = {
13949 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13950 };
13951
13952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13954 if (!SWIG_IsOK(res1)) {
13955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
13956 }
13957 arg1 = reinterpret_cast< wxImage * >(argp1);
13958 {
13959 arg2 = &temp2;
13960 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13961 }
13962 {
13963 arg3 = &temp3;
13964 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13965 }
13966 if (obj3) {
13967 ecode4 = SWIG_AsVal_int(obj3, &val4);
13968 if (!SWIG_IsOK(ecode4)) {
13969 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
13970 }
13971 arg4 = static_cast< int >(val4);
13972 }
13973 if (obj4) {
13974 ecode5 = SWIG_AsVal_int(obj4, &val5);
13975 if (!SWIG_IsOK(ecode5)) {
13976 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
13977 }
13978 arg5 = static_cast< int >(val5);
13979 }
13980 if (obj5) {
13981 ecode6 = SWIG_AsVal_int(obj5, &val6);
13982 if (!SWIG_IsOK(ecode6)) {
13983 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
13984 }
13985 arg6 = static_cast< int >(val6);
13986 }
13987 {
13988 PyThreadState* __tstate = wxPyBeginAllowThreads();
13989 {
13990 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13991 result = (wxImage *) &_result_ref;
13992 }
13993 wxPyEndAllowThreads(__tstate);
13994 if (PyErr_Occurred()) SWIG_fail;
13995 }
13996 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13997 return resultobj;
13998 fail:
13999 return NULL;
14000 }
14001
14002
14003 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14004 PyObject *resultobj = 0;
14005 wxImage *arg1 = (wxImage *) 0 ;
14006 int arg2 ;
14007 int arg3 ;
14008 byte arg4 ;
14009 byte arg5 ;
14010 byte arg6 ;
14011 void *argp1 = 0 ;
14012 int res1 = 0 ;
14013 int val2 ;
14014 int ecode2 = 0 ;
14015 int val3 ;
14016 int ecode3 = 0 ;
14017 unsigned char val4 ;
14018 int ecode4 = 0 ;
14019 unsigned char val5 ;
14020 int ecode5 = 0 ;
14021 unsigned char val6 ;
14022 int ecode6 = 0 ;
14023 PyObject * obj0 = 0 ;
14024 PyObject * obj1 = 0 ;
14025 PyObject * obj2 = 0 ;
14026 PyObject * obj3 = 0 ;
14027 PyObject * obj4 = 0 ;
14028 PyObject * obj5 = 0 ;
14029 char * kwnames[] = {
14030 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
14031 };
14032
14033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
14034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14035 if (!SWIG_IsOK(res1)) {
14036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
14037 }
14038 arg1 = reinterpret_cast< wxImage * >(argp1);
14039 ecode2 = SWIG_AsVal_int(obj1, &val2);
14040 if (!SWIG_IsOK(ecode2)) {
14041 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
14042 }
14043 arg2 = static_cast< int >(val2);
14044 ecode3 = SWIG_AsVal_int(obj2, &val3);
14045 if (!SWIG_IsOK(ecode3)) {
14046 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
14047 }
14048 arg3 = static_cast< int >(val3);
14049 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14050 if (!SWIG_IsOK(ecode4)) {
14051 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
14052 }
14053 arg4 = static_cast< byte >(val4);
14054 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14055 if (!SWIG_IsOK(ecode5)) {
14056 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
14057 }
14058 arg5 = static_cast< byte >(val5);
14059 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
14060 if (!SWIG_IsOK(ecode6)) {
14061 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
14062 }
14063 arg6 = static_cast< byte >(val6);
14064 {
14065 PyThreadState* __tstate = wxPyBeginAllowThreads();
14066 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
14067 wxPyEndAllowThreads(__tstate);
14068 if (PyErr_Occurred()) SWIG_fail;
14069 }
14070 resultobj = SWIG_Py_Void();
14071 return resultobj;
14072 fail:
14073 return NULL;
14074 }
14075
14076
14077 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14078 PyObject *resultobj = 0;
14079 wxImage *arg1 = (wxImage *) 0 ;
14080 wxRect *arg2 = 0 ;
14081 byte arg3 ;
14082 byte arg4 ;
14083 byte arg5 ;
14084 void *argp1 = 0 ;
14085 int res1 = 0 ;
14086 wxRect temp2 ;
14087 unsigned char val3 ;
14088 int ecode3 = 0 ;
14089 unsigned char val4 ;
14090 int ecode4 = 0 ;
14091 unsigned char val5 ;
14092 int ecode5 = 0 ;
14093 PyObject * obj0 = 0 ;
14094 PyObject * obj1 = 0 ;
14095 PyObject * obj2 = 0 ;
14096 PyObject * obj3 = 0 ;
14097 PyObject * obj4 = 0 ;
14098 char * kwnames[] = {
14099 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
14100 };
14101
14102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14104 if (!SWIG_IsOK(res1)) {
14105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
14106 }
14107 arg1 = reinterpret_cast< wxImage * >(argp1);
14108 {
14109 arg2 = &temp2;
14110 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
14111 }
14112 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14113 if (!SWIG_IsOK(ecode3)) {
14114 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
14115 }
14116 arg3 = static_cast< byte >(val3);
14117 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14118 if (!SWIG_IsOK(ecode4)) {
14119 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
14120 }
14121 arg4 = static_cast< byte >(val4);
14122 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14123 if (!SWIG_IsOK(ecode5)) {
14124 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
14125 }
14126 arg5 = static_cast< byte >(val5);
14127 {
14128 PyThreadState* __tstate = wxPyBeginAllowThreads();
14129 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
14130 wxPyEndAllowThreads(__tstate);
14131 if (PyErr_Occurred()) SWIG_fail;
14132 }
14133 resultobj = SWIG_Py_Void();
14134 return resultobj;
14135 fail:
14136 return NULL;
14137 }
14138
14139
14140 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14141 PyObject *resultobj = 0;
14142 wxImage *arg1 = (wxImage *) 0 ;
14143 int arg2 ;
14144 int arg3 ;
14145 byte result;
14146 void *argp1 = 0 ;
14147 int res1 = 0 ;
14148 int val2 ;
14149 int ecode2 = 0 ;
14150 int val3 ;
14151 int ecode3 = 0 ;
14152 PyObject * obj0 = 0 ;
14153 PyObject * obj1 = 0 ;
14154 PyObject * obj2 = 0 ;
14155 char * kwnames[] = {
14156 (char *) "self",(char *) "x",(char *) "y", NULL
14157 };
14158
14159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14161 if (!SWIG_IsOK(res1)) {
14162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
14163 }
14164 arg1 = reinterpret_cast< wxImage * >(argp1);
14165 ecode2 = SWIG_AsVal_int(obj1, &val2);
14166 if (!SWIG_IsOK(ecode2)) {
14167 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
14168 }
14169 arg2 = static_cast< int >(val2);
14170 ecode3 = SWIG_AsVal_int(obj2, &val3);
14171 if (!SWIG_IsOK(ecode3)) {
14172 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
14173 }
14174 arg3 = static_cast< int >(val3);
14175 {
14176 PyThreadState* __tstate = wxPyBeginAllowThreads();
14177 result = (byte)(arg1)->GetRed(arg2,arg3);
14178 wxPyEndAllowThreads(__tstate);
14179 if (PyErr_Occurred()) SWIG_fail;
14180 }
14181 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14182 return resultobj;
14183 fail:
14184 return NULL;
14185 }
14186
14187
14188 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14189 PyObject *resultobj = 0;
14190 wxImage *arg1 = (wxImage *) 0 ;
14191 int arg2 ;
14192 int arg3 ;
14193 byte result;
14194 void *argp1 = 0 ;
14195 int res1 = 0 ;
14196 int val2 ;
14197 int ecode2 = 0 ;
14198 int val3 ;
14199 int ecode3 = 0 ;
14200 PyObject * obj0 = 0 ;
14201 PyObject * obj1 = 0 ;
14202 PyObject * obj2 = 0 ;
14203 char * kwnames[] = {
14204 (char *) "self",(char *) "x",(char *) "y", NULL
14205 };
14206
14207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14209 if (!SWIG_IsOK(res1)) {
14210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
14211 }
14212 arg1 = reinterpret_cast< wxImage * >(argp1);
14213 ecode2 = SWIG_AsVal_int(obj1, &val2);
14214 if (!SWIG_IsOK(ecode2)) {
14215 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
14216 }
14217 arg2 = static_cast< int >(val2);
14218 ecode3 = SWIG_AsVal_int(obj2, &val3);
14219 if (!SWIG_IsOK(ecode3)) {
14220 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
14221 }
14222 arg3 = static_cast< int >(val3);
14223 {
14224 PyThreadState* __tstate = wxPyBeginAllowThreads();
14225 result = (byte)(arg1)->GetGreen(arg2,arg3);
14226 wxPyEndAllowThreads(__tstate);
14227 if (PyErr_Occurred()) SWIG_fail;
14228 }
14229 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14230 return resultobj;
14231 fail:
14232 return NULL;
14233 }
14234
14235
14236 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14237 PyObject *resultobj = 0;
14238 wxImage *arg1 = (wxImage *) 0 ;
14239 int arg2 ;
14240 int arg3 ;
14241 byte result;
14242 void *argp1 = 0 ;
14243 int res1 = 0 ;
14244 int val2 ;
14245 int ecode2 = 0 ;
14246 int val3 ;
14247 int ecode3 = 0 ;
14248 PyObject * obj0 = 0 ;
14249 PyObject * obj1 = 0 ;
14250 PyObject * obj2 = 0 ;
14251 char * kwnames[] = {
14252 (char *) "self",(char *) "x",(char *) "y", NULL
14253 };
14254
14255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14257 if (!SWIG_IsOK(res1)) {
14258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
14259 }
14260 arg1 = reinterpret_cast< wxImage * >(argp1);
14261 ecode2 = SWIG_AsVal_int(obj1, &val2);
14262 if (!SWIG_IsOK(ecode2)) {
14263 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
14264 }
14265 arg2 = static_cast< int >(val2);
14266 ecode3 = SWIG_AsVal_int(obj2, &val3);
14267 if (!SWIG_IsOK(ecode3)) {
14268 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
14269 }
14270 arg3 = static_cast< int >(val3);
14271 {
14272 PyThreadState* __tstate = wxPyBeginAllowThreads();
14273 result = (byte)(arg1)->GetBlue(arg2,arg3);
14274 wxPyEndAllowThreads(__tstate);
14275 if (PyErr_Occurred()) SWIG_fail;
14276 }
14277 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14278 return resultobj;
14279 fail:
14280 return NULL;
14281 }
14282
14283
14284 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14285 PyObject *resultobj = 0;
14286 wxImage *arg1 = (wxImage *) 0 ;
14287 int arg2 ;
14288 int arg3 ;
14289 byte arg4 ;
14290 void *argp1 = 0 ;
14291 int res1 = 0 ;
14292 int val2 ;
14293 int ecode2 = 0 ;
14294 int val3 ;
14295 int ecode3 = 0 ;
14296 unsigned char val4 ;
14297 int ecode4 = 0 ;
14298 PyObject * obj0 = 0 ;
14299 PyObject * obj1 = 0 ;
14300 PyObject * obj2 = 0 ;
14301 PyObject * obj3 = 0 ;
14302 char * kwnames[] = {
14303 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
14304 };
14305
14306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14308 if (!SWIG_IsOK(res1)) {
14309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14310 }
14311 arg1 = reinterpret_cast< wxImage * >(argp1);
14312 ecode2 = SWIG_AsVal_int(obj1, &val2);
14313 if (!SWIG_IsOK(ecode2)) {
14314 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
14315 }
14316 arg2 = static_cast< int >(val2);
14317 ecode3 = SWIG_AsVal_int(obj2, &val3);
14318 if (!SWIG_IsOK(ecode3)) {
14319 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
14320 }
14321 arg3 = static_cast< int >(val3);
14322 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14323 if (!SWIG_IsOK(ecode4)) {
14324 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
14325 }
14326 arg4 = static_cast< byte >(val4);
14327 {
14328 PyThreadState* __tstate = wxPyBeginAllowThreads();
14329 (arg1)->SetAlpha(arg2,arg3,arg4);
14330 wxPyEndAllowThreads(__tstate);
14331 if (PyErr_Occurred()) SWIG_fail;
14332 }
14333 resultobj = SWIG_Py_Void();
14334 return resultobj;
14335 fail:
14336 return NULL;
14337 }
14338
14339
14340 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14341 PyObject *resultobj = 0;
14342 wxImage *arg1 = (wxImage *) 0 ;
14343 int arg2 ;
14344 int arg3 ;
14345 byte result;
14346 void *argp1 = 0 ;
14347 int res1 = 0 ;
14348 int val2 ;
14349 int ecode2 = 0 ;
14350 int val3 ;
14351 int ecode3 = 0 ;
14352 PyObject * obj0 = 0 ;
14353 PyObject * obj1 = 0 ;
14354 PyObject * obj2 = 0 ;
14355 char * kwnames[] = {
14356 (char *) "self",(char *) "x",(char *) "y", NULL
14357 };
14358
14359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14361 if (!SWIG_IsOK(res1)) {
14362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14363 }
14364 arg1 = reinterpret_cast< wxImage * >(argp1);
14365 ecode2 = SWIG_AsVal_int(obj1, &val2);
14366 if (!SWIG_IsOK(ecode2)) {
14367 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
14368 }
14369 arg2 = static_cast< int >(val2);
14370 ecode3 = SWIG_AsVal_int(obj2, &val3);
14371 if (!SWIG_IsOK(ecode3)) {
14372 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
14373 }
14374 arg3 = static_cast< int >(val3);
14375 {
14376 PyThreadState* __tstate = wxPyBeginAllowThreads();
14377 result = (byte)(arg1)->GetAlpha(arg2,arg3);
14378 wxPyEndAllowThreads(__tstate);
14379 if (PyErr_Occurred()) SWIG_fail;
14380 }
14381 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14382 return resultobj;
14383 fail:
14384 return NULL;
14385 }
14386
14387
14388 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14389 PyObject *resultobj = 0;
14390 wxImage *arg1 = (wxImage *) 0 ;
14391 bool result;
14392 void *argp1 = 0 ;
14393 int res1 = 0 ;
14394 PyObject *swig_obj[1] ;
14395
14396 if (!args) SWIG_fail;
14397 swig_obj[0] = args;
14398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14399 if (!SWIG_IsOK(res1)) {
14400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14401 }
14402 arg1 = reinterpret_cast< wxImage * >(argp1);
14403 {
14404 PyThreadState* __tstate = wxPyBeginAllowThreads();
14405 result = (bool)(arg1)->HasAlpha();
14406 wxPyEndAllowThreads(__tstate);
14407 if (PyErr_Occurred()) SWIG_fail;
14408 }
14409 {
14410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14411 }
14412 return resultobj;
14413 fail:
14414 return NULL;
14415 }
14416
14417
14418 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14419 PyObject *resultobj = 0;
14420 wxImage *arg1 = (wxImage *) 0 ;
14421 void *argp1 = 0 ;
14422 int res1 = 0 ;
14423 PyObject *swig_obj[1] ;
14424
14425 if (!args) SWIG_fail;
14426 swig_obj[0] = args;
14427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14428 if (!SWIG_IsOK(res1)) {
14429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14430 }
14431 arg1 = reinterpret_cast< wxImage * >(argp1);
14432 {
14433 PyThreadState* __tstate = wxPyBeginAllowThreads();
14434 (arg1)->InitAlpha();
14435 wxPyEndAllowThreads(__tstate);
14436 if (PyErr_Occurred()) SWIG_fail;
14437 }
14438 resultobj = SWIG_Py_Void();
14439 return resultobj;
14440 fail:
14441 return NULL;
14442 }
14443
14444
14445 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14446 PyObject *resultobj = 0;
14447 wxImage *arg1 = (wxImage *) 0 ;
14448 int arg2 ;
14449 int arg3 ;
14450 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14451 bool result;
14452 void *argp1 = 0 ;
14453 int res1 = 0 ;
14454 int val2 ;
14455 int ecode2 = 0 ;
14456 int val3 ;
14457 int ecode3 = 0 ;
14458 unsigned char val4 ;
14459 int ecode4 = 0 ;
14460 PyObject * obj0 = 0 ;
14461 PyObject * obj1 = 0 ;
14462 PyObject * obj2 = 0 ;
14463 PyObject * obj3 = 0 ;
14464 char * kwnames[] = {
14465 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14466 };
14467
14468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14470 if (!SWIG_IsOK(res1)) {
14471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14472 }
14473 arg1 = reinterpret_cast< wxImage * >(argp1);
14474 ecode2 = SWIG_AsVal_int(obj1, &val2);
14475 if (!SWIG_IsOK(ecode2)) {
14476 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14477 }
14478 arg2 = static_cast< int >(val2);
14479 ecode3 = SWIG_AsVal_int(obj2, &val3);
14480 if (!SWIG_IsOK(ecode3)) {
14481 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14482 }
14483 arg3 = static_cast< int >(val3);
14484 if (obj3) {
14485 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14486 if (!SWIG_IsOK(ecode4)) {
14487 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14488 }
14489 arg4 = static_cast< byte >(val4);
14490 }
14491 {
14492 PyThreadState* __tstate = wxPyBeginAllowThreads();
14493 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14494 wxPyEndAllowThreads(__tstate);
14495 if (PyErr_Occurred()) SWIG_fail;
14496 }
14497 {
14498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14499 }
14500 return resultobj;
14501 fail:
14502 return NULL;
14503 }
14504
14505
14506 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14507 PyObject *resultobj = 0;
14508 wxImage *arg1 = (wxImage *) 0 ;
14509 byte *arg2 = (byte *) 0 ;
14510 byte *arg3 = (byte *) 0 ;
14511 byte *arg4 = (byte *) 0 ;
14512 byte arg5 = (byte) 0 ;
14513 byte arg6 = (byte) 0 ;
14514 byte arg7 = (byte) 0 ;
14515 bool result;
14516 void *argp1 = 0 ;
14517 int res1 = 0 ;
14518 byte temp2 ;
14519 int res2 = SWIG_TMPOBJ ;
14520 byte temp3 ;
14521 int res3 = SWIG_TMPOBJ ;
14522 byte temp4 ;
14523 int res4 = SWIG_TMPOBJ ;
14524 unsigned char val5 ;
14525 int ecode5 = 0 ;
14526 unsigned char val6 ;
14527 int ecode6 = 0 ;
14528 unsigned char val7 ;
14529 int ecode7 = 0 ;
14530 PyObject * obj0 = 0 ;
14531 PyObject * obj1 = 0 ;
14532 PyObject * obj2 = 0 ;
14533 PyObject * obj3 = 0 ;
14534 char * kwnames[] = {
14535 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14536 };
14537
14538 arg2 = &temp2;
14539 arg3 = &temp3;
14540 arg4 = &temp4;
14541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14543 if (!SWIG_IsOK(res1)) {
14544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14545 }
14546 arg1 = reinterpret_cast< wxImage * >(argp1);
14547 if (obj1) {
14548 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14549 if (!SWIG_IsOK(ecode5)) {
14550 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14551 }
14552 arg5 = static_cast< byte >(val5);
14553 }
14554 if (obj2) {
14555 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14556 if (!SWIG_IsOK(ecode6)) {
14557 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14558 }
14559 arg6 = static_cast< byte >(val6);
14560 }
14561 if (obj3) {
14562 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14563 if (!SWIG_IsOK(ecode7)) {
14564 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14565 }
14566 arg7 = static_cast< byte >(val7);
14567 }
14568 {
14569 PyThreadState* __tstate = wxPyBeginAllowThreads();
14570 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14571 wxPyEndAllowThreads(__tstate);
14572 if (PyErr_Occurred()) SWIG_fail;
14573 }
14574 {
14575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14576 }
14577 if (SWIG_IsTmpObj(res2)) {
14578 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14579 } else {
14580 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14581 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14582 }
14583 if (SWIG_IsTmpObj(res3)) {
14584 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14585 } else {
14586 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14587 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14588 }
14589 if (SWIG_IsTmpObj(res4)) {
14590 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14591 } else {
14592 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14593 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14594 }
14595 return resultobj;
14596 fail:
14597 return NULL;
14598 }
14599
14600
14601 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14602 PyObject *resultobj = 0;
14603 wxImage *arg1 = (wxImage *) 0 ;
14604 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14605 bool result;
14606 void *argp1 = 0 ;
14607 int res1 = 0 ;
14608 unsigned char val2 ;
14609 int ecode2 = 0 ;
14610 PyObject * obj0 = 0 ;
14611 PyObject * obj1 = 0 ;
14612 char * kwnames[] = {
14613 (char *) "self",(char *) "threshold", NULL
14614 };
14615
14616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14618 if (!SWIG_IsOK(res1)) {
14619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14620 }
14621 arg1 = reinterpret_cast< wxImage * >(argp1);
14622 if (obj1) {
14623 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14624 if (!SWIG_IsOK(ecode2)) {
14625 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14626 }
14627 arg2 = static_cast< byte >(val2);
14628 }
14629 {
14630 PyThreadState* __tstate = wxPyBeginAllowThreads();
14631 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14632 wxPyEndAllowThreads(__tstate);
14633 if (PyErr_Occurred()) SWIG_fail;
14634 }
14635 {
14636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14637 }
14638 return resultobj;
14639 fail:
14640 return NULL;
14641 }
14642
14643
14644 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14645 PyObject *resultobj = 0;
14646 wxImage *arg1 = (wxImage *) 0 ;
14647 byte arg2 ;
14648 byte arg3 ;
14649 byte arg4 ;
14650 bool result;
14651 void *argp1 = 0 ;
14652 int res1 = 0 ;
14653 unsigned char val2 ;
14654 int ecode2 = 0 ;
14655 unsigned char val3 ;
14656 int ecode3 = 0 ;
14657 unsigned char val4 ;
14658 int ecode4 = 0 ;
14659 PyObject * obj0 = 0 ;
14660 PyObject * obj1 = 0 ;
14661 PyObject * obj2 = 0 ;
14662 PyObject * obj3 = 0 ;
14663 char * kwnames[] = {
14664 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14665 };
14666
14667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14669 if (!SWIG_IsOK(res1)) {
14670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14671 }
14672 arg1 = reinterpret_cast< wxImage * >(argp1);
14673 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14674 if (!SWIG_IsOK(ecode2)) {
14675 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14676 }
14677 arg2 = static_cast< byte >(val2);
14678 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14679 if (!SWIG_IsOK(ecode3)) {
14680 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
14681 }
14682 arg3 = static_cast< byte >(val3);
14683 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14684 if (!SWIG_IsOK(ecode4)) {
14685 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
14686 }
14687 arg4 = static_cast< byte >(val4);
14688 {
14689 PyThreadState* __tstate = wxPyBeginAllowThreads();
14690 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
14691 wxPyEndAllowThreads(__tstate);
14692 if (PyErr_Occurred()) SWIG_fail;
14693 }
14694 {
14695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14696 }
14697 return resultobj;
14698 fail:
14699 return NULL;
14700 }
14701
14702
14703 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14704 PyObject *resultobj = 0;
14705 wxImage *arg1 = (wxImage *) 0 ;
14706 wxImage *arg2 = 0 ;
14707 byte arg3 ;
14708 byte arg4 ;
14709 byte arg5 ;
14710 bool result;
14711 void *argp1 = 0 ;
14712 int res1 = 0 ;
14713 void *argp2 = 0 ;
14714 int res2 = 0 ;
14715 unsigned char val3 ;
14716 int ecode3 = 0 ;
14717 unsigned char val4 ;
14718 int ecode4 = 0 ;
14719 unsigned char val5 ;
14720 int ecode5 = 0 ;
14721 PyObject * obj0 = 0 ;
14722 PyObject * obj1 = 0 ;
14723 PyObject * obj2 = 0 ;
14724 PyObject * obj3 = 0 ;
14725 PyObject * obj4 = 0 ;
14726 char * kwnames[] = {
14727 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
14728 };
14729
14730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14732 if (!SWIG_IsOK(res1)) {
14733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
14734 }
14735 arg1 = reinterpret_cast< wxImage * >(argp1);
14736 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
14737 if (!SWIG_IsOK(res2)) {
14738 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14739 }
14740 if (!argp2) {
14741 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14742 }
14743 arg2 = reinterpret_cast< wxImage * >(argp2);
14744 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14745 if (!SWIG_IsOK(ecode3)) {
14746 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
14747 }
14748 arg3 = static_cast< byte >(val3);
14749 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14750 if (!SWIG_IsOK(ecode4)) {
14751 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
14752 }
14753 arg4 = static_cast< byte >(val4);
14754 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14755 if (!SWIG_IsOK(ecode5)) {
14756 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
14757 }
14758 arg5 = static_cast< byte >(val5);
14759 {
14760 PyThreadState* __tstate = wxPyBeginAllowThreads();
14761 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
14762 wxPyEndAllowThreads(__tstate);
14763 if (PyErr_Occurred()) SWIG_fail;
14764 }
14765 {
14766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14767 }
14768 return resultobj;
14769 fail:
14770 return NULL;
14771 }
14772
14773
14774 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14775 PyObject *resultobj = 0;
14776 wxString *arg1 = 0 ;
14777 bool result;
14778 bool temp1 = false ;
14779 PyObject * obj0 = 0 ;
14780 char * kwnames[] = {
14781 (char *) "filename", NULL
14782 };
14783
14784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
14785 {
14786 arg1 = wxString_in_helper(obj0);
14787 if (arg1 == NULL) SWIG_fail;
14788 temp1 = true;
14789 }
14790 {
14791 PyThreadState* __tstate = wxPyBeginAllowThreads();
14792 result = (bool)wxImage::CanRead((wxString const &)*arg1);
14793 wxPyEndAllowThreads(__tstate);
14794 if (PyErr_Occurred()) SWIG_fail;
14795 }
14796 {
14797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14798 }
14799 {
14800 if (temp1)
14801 delete arg1;
14802 }
14803 return resultobj;
14804 fail:
14805 {
14806 if (temp1)
14807 delete arg1;
14808 }
14809 return NULL;
14810 }
14811
14812
14813 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14814 PyObject *resultobj = 0;
14815 wxString *arg1 = 0 ;
14816 long arg2 = (long) wxBITMAP_TYPE_ANY ;
14817 int result;
14818 bool temp1 = false ;
14819 long val2 ;
14820 int ecode2 = 0 ;
14821 PyObject * obj0 = 0 ;
14822 PyObject * obj1 = 0 ;
14823 char * kwnames[] = {
14824 (char *) "filename",(char *) "type", NULL
14825 };
14826
14827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
14828 {
14829 arg1 = wxString_in_helper(obj0);
14830 if (arg1 == NULL) SWIG_fail;
14831 temp1 = true;
14832 }
14833 if (obj1) {
14834 ecode2 = SWIG_AsVal_long(obj1, &val2);
14835 if (!SWIG_IsOK(ecode2)) {
14836 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
14837 }
14838 arg2 = static_cast< long >(val2);
14839 }
14840 {
14841 PyThreadState* __tstate = wxPyBeginAllowThreads();
14842 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
14843 wxPyEndAllowThreads(__tstate);
14844 if (PyErr_Occurred()) SWIG_fail;
14845 }
14846 resultobj = SWIG_From_int(static_cast< int >(result));
14847 {
14848 if (temp1)
14849 delete arg1;
14850 }
14851 return resultobj;
14852 fail:
14853 {
14854 if (temp1)
14855 delete arg1;
14856 }
14857 return NULL;
14858 }
14859
14860
14861 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14862 PyObject *resultobj = 0;
14863 wxImage *arg1 = (wxImage *) 0 ;
14864 wxString *arg2 = 0 ;
14865 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14866 int arg4 = (int) -1 ;
14867 bool result;
14868 void *argp1 = 0 ;
14869 int res1 = 0 ;
14870 bool temp2 = false ;
14871 long val3 ;
14872 int ecode3 = 0 ;
14873 int val4 ;
14874 int ecode4 = 0 ;
14875 PyObject * obj0 = 0 ;
14876 PyObject * obj1 = 0 ;
14877 PyObject * obj2 = 0 ;
14878 PyObject * obj3 = 0 ;
14879 char * kwnames[] = {
14880 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
14881 };
14882
14883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14885 if (!SWIG_IsOK(res1)) {
14886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
14887 }
14888 arg1 = reinterpret_cast< wxImage * >(argp1);
14889 {
14890 arg2 = wxString_in_helper(obj1);
14891 if (arg2 == NULL) SWIG_fail;
14892 temp2 = true;
14893 }
14894 if (obj2) {
14895 ecode3 = SWIG_AsVal_long(obj2, &val3);
14896 if (!SWIG_IsOK(ecode3)) {
14897 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
14898 }
14899 arg3 = static_cast< long >(val3);
14900 }
14901 if (obj3) {
14902 ecode4 = SWIG_AsVal_int(obj3, &val4);
14903 if (!SWIG_IsOK(ecode4)) {
14904 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
14905 }
14906 arg4 = static_cast< int >(val4);
14907 }
14908 {
14909 PyThreadState* __tstate = wxPyBeginAllowThreads();
14910 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
14911 wxPyEndAllowThreads(__tstate);
14912 if (PyErr_Occurred()) SWIG_fail;
14913 }
14914 {
14915 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14916 }
14917 {
14918 if (temp2)
14919 delete arg2;
14920 }
14921 return resultobj;
14922 fail:
14923 {
14924 if (temp2)
14925 delete arg2;
14926 }
14927 return NULL;
14928 }
14929
14930
14931 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14932 PyObject *resultobj = 0;
14933 wxImage *arg1 = (wxImage *) 0 ;
14934 wxString *arg2 = 0 ;
14935 wxString *arg3 = 0 ;
14936 int arg4 = (int) -1 ;
14937 bool result;
14938 void *argp1 = 0 ;
14939 int res1 = 0 ;
14940 bool temp2 = false ;
14941 bool temp3 = false ;
14942 int val4 ;
14943 int ecode4 = 0 ;
14944 PyObject * obj0 = 0 ;
14945 PyObject * obj1 = 0 ;
14946 PyObject * obj2 = 0 ;
14947 PyObject * obj3 = 0 ;
14948 char * kwnames[] = {
14949 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
14950 };
14951
14952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14954 if (!SWIG_IsOK(res1)) {
14955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14956 }
14957 arg1 = reinterpret_cast< wxImage * >(argp1);
14958 {
14959 arg2 = wxString_in_helper(obj1);
14960 if (arg2 == NULL) SWIG_fail;
14961 temp2 = true;
14962 }
14963 {
14964 arg3 = wxString_in_helper(obj2);
14965 if (arg3 == NULL) SWIG_fail;
14966 temp3 = true;
14967 }
14968 if (obj3) {
14969 ecode4 = SWIG_AsVal_int(obj3, &val4);
14970 if (!SWIG_IsOK(ecode4)) {
14971 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
14972 }
14973 arg4 = static_cast< int >(val4);
14974 }
14975 {
14976 PyThreadState* __tstate = wxPyBeginAllowThreads();
14977 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14978 wxPyEndAllowThreads(__tstate);
14979 if (PyErr_Occurred()) SWIG_fail;
14980 }
14981 {
14982 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14983 }
14984 {
14985 if (temp2)
14986 delete arg2;
14987 }
14988 {
14989 if (temp3)
14990 delete arg3;
14991 }
14992 return resultobj;
14993 fail:
14994 {
14995 if (temp2)
14996 delete arg2;
14997 }
14998 {
14999 if (temp3)
15000 delete arg3;
15001 }
15002 return NULL;
15003 }
15004
15005
15006 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15007 PyObject *resultobj = 0;
15008 wxImage *arg1 = (wxImage *) 0 ;
15009 wxString *arg2 = 0 ;
15010 int arg3 ;
15011 bool result;
15012 void *argp1 = 0 ;
15013 int res1 = 0 ;
15014 bool temp2 = false ;
15015 int val3 ;
15016 int ecode3 = 0 ;
15017 PyObject * obj0 = 0 ;
15018 PyObject * obj1 = 0 ;
15019 PyObject * obj2 = 0 ;
15020 char * kwnames[] = {
15021 (char *) "self",(char *) "name",(char *) "type", NULL
15022 };
15023
15024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15026 if (!SWIG_IsOK(res1)) {
15027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
15028 }
15029 arg1 = reinterpret_cast< wxImage * >(argp1);
15030 {
15031 arg2 = wxString_in_helper(obj1);
15032 if (arg2 == NULL) SWIG_fail;
15033 temp2 = true;
15034 }
15035 ecode3 = SWIG_AsVal_int(obj2, &val3);
15036 if (!SWIG_IsOK(ecode3)) {
15037 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
15038 }
15039 arg3 = static_cast< int >(val3);
15040 {
15041 PyThreadState* __tstate = wxPyBeginAllowThreads();
15042 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
15043 wxPyEndAllowThreads(__tstate);
15044 if (PyErr_Occurred()) SWIG_fail;
15045 }
15046 {
15047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15048 }
15049 {
15050 if (temp2)
15051 delete arg2;
15052 }
15053 return resultobj;
15054 fail:
15055 {
15056 if (temp2)
15057 delete arg2;
15058 }
15059 return NULL;
15060 }
15061
15062
15063 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15064 PyObject *resultobj = 0;
15065 wxImage *arg1 = (wxImage *) 0 ;
15066 wxString *arg2 = 0 ;
15067 wxString *arg3 = 0 ;
15068 bool result;
15069 void *argp1 = 0 ;
15070 int res1 = 0 ;
15071 bool temp2 = false ;
15072 bool temp3 = false ;
15073 PyObject * obj0 = 0 ;
15074 PyObject * obj1 = 0 ;
15075 PyObject * obj2 = 0 ;
15076 char * kwnames[] = {
15077 (char *) "self",(char *) "name",(char *) "mimetype", NULL
15078 };
15079
15080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15082 if (!SWIG_IsOK(res1)) {
15083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
15084 }
15085 arg1 = reinterpret_cast< wxImage * >(argp1);
15086 {
15087 arg2 = wxString_in_helper(obj1);
15088 if (arg2 == NULL) SWIG_fail;
15089 temp2 = true;
15090 }
15091 {
15092 arg3 = wxString_in_helper(obj2);
15093 if (arg3 == NULL) SWIG_fail;
15094 temp3 = true;
15095 }
15096 {
15097 PyThreadState* __tstate = wxPyBeginAllowThreads();
15098 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
15099 wxPyEndAllowThreads(__tstate);
15100 if (PyErr_Occurred()) SWIG_fail;
15101 }
15102 {
15103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15104 }
15105 {
15106 if (temp2)
15107 delete arg2;
15108 }
15109 {
15110 if (temp3)
15111 delete arg3;
15112 }
15113 return resultobj;
15114 fail:
15115 {
15116 if (temp2)
15117 delete arg2;
15118 }
15119 {
15120 if (temp3)
15121 delete arg3;
15122 }
15123 return NULL;
15124 }
15125
15126
15127 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15128 PyObject *resultobj = 0;
15129 wxInputStream *arg1 = 0 ;
15130 bool result;
15131 wxPyInputStream *temp1 ;
15132 bool created1 ;
15133 PyObject * obj0 = 0 ;
15134 char * kwnames[] = {
15135 (char *) "stream", NULL
15136 };
15137
15138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
15139 {
15140 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15141 arg1 = temp1->m_wxis;
15142 created1 = false;
15143 } else {
15144 PyErr_Clear(); // clear the failure of the wxPyConvert above
15145 arg1 = wxPyCBInputStream_create(obj0, false);
15146 if (arg1 == NULL) {
15147 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15148 SWIG_fail;
15149 }
15150 created1 = true;
15151 }
15152 }
15153 {
15154 PyThreadState* __tstate = wxPyBeginAllowThreads();
15155 result = (bool)wxImage::CanRead(*arg1);
15156 wxPyEndAllowThreads(__tstate);
15157 if (PyErr_Occurred()) SWIG_fail;
15158 }
15159 {
15160 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15161 }
15162 {
15163 if (created1) delete arg1;
15164 }
15165 return resultobj;
15166 fail:
15167 {
15168 if (created1) delete arg1;
15169 }
15170 return NULL;
15171 }
15172
15173
15174 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15175 PyObject *resultobj = 0;
15176 wxImage *arg1 = (wxImage *) 0 ;
15177 wxInputStream *arg2 = 0 ;
15178 long arg3 = (long) wxBITMAP_TYPE_ANY ;
15179 int arg4 = (int) -1 ;
15180 bool result;
15181 void *argp1 = 0 ;
15182 int res1 = 0 ;
15183 wxPyInputStream *temp2 ;
15184 bool created2 ;
15185 long val3 ;
15186 int ecode3 = 0 ;
15187 int val4 ;
15188 int ecode4 = 0 ;
15189 PyObject * obj0 = 0 ;
15190 PyObject * obj1 = 0 ;
15191 PyObject * obj2 = 0 ;
15192 PyObject * obj3 = 0 ;
15193 char * kwnames[] = {
15194 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
15195 };
15196
15197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15199 if (!SWIG_IsOK(res1)) {
15200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
15201 }
15202 arg1 = reinterpret_cast< wxImage * >(argp1);
15203 {
15204 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15205 arg2 = temp2->m_wxis;
15206 created2 = false;
15207 } else {
15208 PyErr_Clear(); // clear the failure of the wxPyConvert above
15209 arg2 = wxPyCBInputStream_create(obj1, false);
15210 if (arg2 == NULL) {
15211 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15212 SWIG_fail;
15213 }
15214 created2 = true;
15215 }
15216 }
15217 if (obj2) {
15218 ecode3 = SWIG_AsVal_long(obj2, &val3);
15219 if (!SWIG_IsOK(ecode3)) {
15220 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
15221 }
15222 arg3 = static_cast< long >(val3);
15223 }
15224 if (obj3) {
15225 ecode4 = SWIG_AsVal_int(obj3, &val4);
15226 if (!SWIG_IsOK(ecode4)) {
15227 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
15228 }
15229 arg4 = static_cast< int >(val4);
15230 }
15231 {
15232 PyThreadState* __tstate = wxPyBeginAllowThreads();
15233 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
15234 wxPyEndAllowThreads(__tstate);
15235 if (PyErr_Occurred()) SWIG_fail;
15236 }
15237 {
15238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15239 }
15240 {
15241 if (created2) delete arg2;
15242 }
15243 return resultobj;
15244 fail:
15245 {
15246 if (created2) delete arg2;
15247 }
15248 return NULL;
15249 }
15250
15251
15252 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15253 PyObject *resultobj = 0;
15254 wxImage *arg1 = (wxImage *) 0 ;
15255 wxInputStream *arg2 = 0 ;
15256 wxString *arg3 = 0 ;
15257 int arg4 = (int) -1 ;
15258 bool result;
15259 void *argp1 = 0 ;
15260 int res1 = 0 ;
15261 wxPyInputStream *temp2 ;
15262 bool created2 ;
15263 bool temp3 = false ;
15264 int val4 ;
15265 int ecode4 = 0 ;
15266 PyObject * obj0 = 0 ;
15267 PyObject * obj1 = 0 ;
15268 PyObject * obj2 = 0 ;
15269 PyObject * obj3 = 0 ;
15270 char * kwnames[] = {
15271 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
15272 };
15273
15274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15276 if (!SWIG_IsOK(res1)) {
15277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
15278 }
15279 arg1 = reinterpret_cast< wxImage * >(argp1);
15280 {
15281 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15282 arg2 = temp2->m_wxis;
15283 created2 = false;
15284 } else {
15285 PyErr_Clear(); // clear the failure of the wxPyConvert above
15286 arg2 = wxPyCBInputStream_create(obj1, false);
15287 if (arg2 == NULL) {
15288 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15289 SWIG_fail;
15290 }
15291 created2 = true;
15292 }
15293 }
15294 {
15295 arg3 = wxString_in_helper(obj2);
15296 if (arg3 == NULL) SWIG_fail;
15297 temp3 = true;
15298 }
15299 if (obj3) {
15300 ecode4 = SWIG_AsVal_int(obj3, &val4);
15301 if (!SWIG_IsOK(ecode4)) {
15302 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
15303 }
15304 arg4 = static_cast< int >(val4);
15305 }
15306 {
15307 PyThreadState* __tstate = wxPyBeginAllowThreads();
15308 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
15309 wxPyEndAllowThreads(__tstate);
15310 if (PyErr_Occurred()) SWIG_fail;
15311 }
15312 {
15313 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15314 }
15315 {
15316 if (created2) delete arg2;
15317 }
15318 {
15319 if (temp3)
15320 delete arg3;
15321 }
15322 return resultobj;
15323 fail:
15324 {
15325 if (created2) delete arg2;
15326 }
15327 {
15328 if (temp3)
15329 delete arg3;
15330 }
15331 return NULL;
15332 }
15333
15334
15335 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15336 PyObject *resultobj = 0;
15337 wxImage *arg1 = (wxImage *) 0 ;
15338 bool result;
15339 void *argp1 = 0 ;
15340 int res1 = 0 ;
15341 PyObject *swig_obj[1] ;
15342
15343 if (!args) SWIG_fail;
15344 swig_obj[0] = args;
15345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15346 if (!SWIG_IsOK(res1)) {
15347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
15348 }
15349 arg1 = reinterpret_cast< wxImage * >(argp1);
15350 {
15351 PyThreadState* __tstate = wxPyBeginAllowThreads();
15352 result = (bool)(arg1)->Ok();
15353 wxPyEndAllowThreads(__tstate);
15354 if (PyErr_Occurred()) SWIG_fail;
15355 }
15356 {
15357 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15358 }
15359 return resultobj;
15360 fail:
15361 return NULL;
15362 }
15363
15364
15365 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15366 PyObject *resultobj = 0;
15367 wxImage *arg1 = (wxImage *) 0 ;
15368 int result;
15369 void *argp1 = 0 ;
15370 int res1 = 0 ;
15371 PyObject *swig_obj[1] ;
15372
15373 if (!args) SWIG_fail;
15374 swig_obj[0] = args;
15375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15376 if (!SWIG_IsOK(res1)) {
15377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
15378 }
15379 arg1 = reinterpret_cast< wxImage * >(argp1);
15380 {
15381 PyThreadState* __tstate = wxPyBeginAllowThreads();
15382 result = (int)(arg1)->GetWidth();
15383 wxPyEndAllowThreads(__tstate);
15384 if (PyErr_Occurred()) SWIG_fail;
15385 }
15386 resultobj = SWIG_From_int(static_cast< int >(result));
15387 return resultobj;
15388 fail:
15389 return NULL;
15390 }
15391
15392
15393 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15394 PyObject *resultobj = 0;
15395 wxImage *arg1 = (wxImage *) 0 ;
15396 int result;
15397 void *argp1 = 0 ;
15398 int res1 = 0 ;
15399 PyObject *swig_obj[1] ;
15400
15401 if (!args) SWIG_fail;
15402 swig_obj[0] = args;
15403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15404 if (!SWIG_IsOK(res1)) {
15405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15406 }
15407 arg1 = reinterpret_cast< wxImage * >(argp1);
15408 {
15409 PyThreadState* __tstate = wxPyBeginAllowThreads();
15410 result = (int)(arg1)->GetHeight();
15411 wxPyEndAllowThreads(__tstate);
15412 if (PyErr_Occurred()) SWIG_fail;
15413 }
15414 resultobj = SWIG_From_int(static_cast< int >(result));
15415 return resultobj;
15416 fail:
15417 return NULL;
15418 }
15419
15420
15421 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15422 PyObject *resultobj = 0;
15423 wxImage *arg1 = (wxImage *) 0 ;
15424 wxSize result;
15425 void *argp1 = 0 ;
15426 int res1 = 0 ;
15427 PyObject *swig_obj[1] ;
15428
15429 if (!args) SWIG_fail;
15430 swig_obj[0] = args;
15431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15432 if (!SWIG_IsOK(res1)) {
15433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15434 }
15435 arg1 = reinterpret_cast< wxImage * >(argp1);
15436 {
15437 PyThreadState* __tstate = wxPyBeginAllowThreads();
15438 result = wxImage_GetSize(arg1);
15439 wxPyEndAllowThreads(__tstate);
15440 if (PyErr_Occurred()) SWIG_fail;
15441 }
15442 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15443 return resultobj;
15444 fail:
15445 return NULL;
15446 }
15447
15448
15449 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15450 PyObject *resultobj = 0;
15451 wxImage *arg1 = (wxImage *) 0 ;
15452 wxRect *arg2 = 0 ;
15453 SwigValueWrapper<wxImage > result;
15454 void *argp1 = 0 ;
15455 int res1 = 0 ;
15456 wxRect temp2 ;
15457 PyObject * obj0 = 0 ;
15458 PyObject * obj1 = 0 ;
15459 char * kwnames[] = {
15460 (char *) "self",(char *) "rect", NULL
15461 };
15462
15463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15465 if (!SWIG_IsOK(res1)) {
15466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15467 }
15468 arg1 = reinterpret_cast< wxImage * >(argp1);
15469 {
15470 arg2 = &temp2;
15471 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15472 }
15473 {
15474 PyThreadState* __tstate = wxPyBeginAllowThreads();
15475 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15476 wxPyEndAllowThreads(__tstate);
15477 if (PyErr_Occurred()) SWIG_fail;
15478 }
15479 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15480 return resultobj;
15481 fail:
15482 return NULL;
15483 }
15484
15485
15486 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15487 PyObject *resultobj = 0;
15488 wxImage *arg1 = (wxImage *) 0 ;
15489 wxSize *arg2 = 0 ;
15490 wxPoint *arg3 = 0 ;
15491 int arg4 = (int) -1 ;
15492 int arg5 = (int) -1 ;
15493 int arg6 = (int) -1 ;
15494 SwigValueWrapper<wxImage > result;
15495 void *argp1 = 0 ;
15496 int res1 = 0 ;
15497 wxSize temp2 ;
15498 wxPoint temp3 ;
15499 int val4 ;
15500 int ecode4 = 0 ;
15501 int val5 ;
15502 int ecode5 = 0 ;
15503 int val6 ;
15504 int ecode6 = 0 ;
15505 PyObject * obj0 = 0 ;
15506 PyObject * obj1 = 0 ;
15507 PyObject * obj2 = 0 ;
15508 PyObject * obj3 = 0 ;
15509 PyObject * obj4 = 0 ;
15510 PyObject * obj5 = 0 ;
15511 char * kwnames[] = {
15512 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15513 };
15514
15515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15517 if (!SWIG_IsOK(res1)) {
15518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15519 }
15520 arg1 = reinterpret_cast< wxImage * >(argp1);
15521 {
15522 arg2 = &temp2;
15523 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15524 }
15525 {
15526 arg3 = &temp3;
15527 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15528 }
15529 if (obj3) {
15530 ecode4 = SWIG_AsVal_int(obj3, &val4);
15531 if (!SWIG_IsOK(ecode4)) {
15532 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15533 }
15534 arg4 = static_cast< int >(val4);
15535 }
15536 if (obj4) {
15537 ecode5 = SWIG_AsVal_int(obj4, &val5);
15538 if (!SWIG_IsOK(ecode5)) {
15539 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15540 }
15541 arg5 = static_cast< int >(val5);
15542 }
15543 if (obj5) {
15544 ecode6 = SWIG_AsVal_int(obj5, &val6);
15545 if (!SWIG_IsOK(ecode6)) {
15546 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15547 }
15548 arg6 = static_cast< int >(val6);
15549 }
15550 {
15551 PyThreadState* __tstate = wxPyBeginAllowThreads();
15552 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15553 wxPyEndAllowThreads(__tstate);
15554 if (PyErr_Occurred()) SWIG_fail;
15555 }
15556 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15557 return resultobj;
15558 fail:
15559 return NULL;
15560 }
15561
15562
15563 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15564 PyObject *resultobj = 0;
15565 wxImage *arg1 = (wxImage *) 0 ;
15566 SwigValueWrapper<wxImage > result;
15567 void *argp1 = 0 ;
15568 int res1 = 0 ;
15569 PyObject *swig_obj[1] ;
15570
15571 if (!args) SWIG_fail;
15572 swig_obj[0] = args;
15573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15574 if (!SWIG_IsOK(res1)) {
15575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15576 }
15577 arg1 = reinterpret_cast< wxImage * >(argp1);
15578 {
15579 PyThreadState* __tstate = wxPyBeginAllowThreads();
15580 result = (arg1)->Copy();
15581 wxPyEndAllowThreads(__tstate);
15582 if (PyErr_Occurred()) SWIG_fail;
15583 }
15584 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15585 return resultobj;
15586 fail:
15587 return NULL;
15588 }
15589
15590
15591 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15592 PyObject *resultobj = 0;
15593 wxImage *arg1 = (wxImage *) 0 ;
15594 wxImage *arg2 = 0 ;
15595 int arg3 ;
15596 int arg4 ;
15597 void *argp1 = 0 ;
15598 int res1 = 0 ;
15599 void *argp2 = 0 ;
15600 int res2 = 0 ;
15601 int val3 ;
15602 int ecode3 = 0 ;
15603 int val4 ;
15604 int ecode4 = 0 ;
15605 PyObject * obj0 = 0 ;
15606 PyObject * obj1 = 0 ;
15607 PyObject * obj2 = 0 ;
15608 PyObject * obj3 = 0 ;
15609 char * kwnames[] = {
15610 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15611 };
15612
15613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15615 if (!SWIG_IsOK(res1)) {
15616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15617 }
15618 arg1 = reinterpret_cast< wxImage * >(argp1);
15619 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15620 if (!SWIG_IsOK(res2)) {
15621 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15622 }
15623 if (!argp2) {
15624 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15625 }
15626 arg2 = reinterpret_cast< wxImage * >(argp2);
15627 ecode3 = SWIG_AsVal_int(obj2, &val3);
15628 if (!SWIG_IsOK(ecode3)) {
15629 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15630 }
15631 arg3 = static_cast< int >(val3);
15632 ecode4 = SWIG_AsVal_int(obj3, &val4);
15633 if (!SWIG_IsOK(ecode4)) {
15634 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15635 }
15636 arg4 = static_cast< int >(val4);
15637 {
15638 PyThreadState* __tstate = wxPyBeginAllowThreads();
15639 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15640 wxPyEndAllowThreads(__tstate);
15641 if (PyErr_Occurred()) SWIG_fail;
15642 }
15643 resultobj = SWIG_Py_Void();
15644 return resultobj;
15645 fail:
15646 return NULL;
15647 }
15648
15649
15650 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15651 PyObject *resultobj = 0;
15652 wxImage *arg1 = (wxImage *) 0 ;
15653 PyObject *result = 0 ;
15654 void *argp1 = 0 ;
15655 int res1 = 0 ;
15656 PyObject *swig_obj[1] ;
15657
15658 if (!args) SWIG_fail;
15659 swig_obj[0] = args;
15660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15661 if (!SWIG_IsOK(res1)) {
15662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15663 }
15664 arg1 = reinterpret_cast< wxImage * >(argp1);
15665 {
15666 PyThreadState* __tstate = wxPyBeginAllowThreads();
15667 result = (PyObject *)wxImage_GetData(arg1);
15668 wxPyEndAllowThreads(__tstate);
15669 if (PyErr_Occurred()) SWIG_fail;
15670 }
15671 resultobj = result;
15672 return resultobj;
15673 fail:
15674 return NULL;
15675 }
15676
15677
15678 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15679 PyObject *resultobj = 0;
15680 wxImage *arg1 = (wxImage *) 0 ;
15681 buffer arg2 ;
15682 int arg3 ;
15683 void *argp1 = 0 ;
15684 int res1 = 0 ;
15685 Py_ssize_t temp2 ;
15686 PyObject * obj0 = 0 ;
15687 PyObject * obj1 = 0 ;
15688 char * kwnames[] = {
15689 (char *) "self",(char *) "data", NULL
15690 };
15691
15692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
15693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15694 if (!SWIG_IsOK(res1)) {
15695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
15696 }
15697 arg1 = reinterpret_cast< wxImage * >(argp1);
15698 {
15699 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
15700 arg3 = (int)temp2;
15701 }
15702 {
15703 PyThreadState* __tstate = wxPyBeginAllowThreads();
15704 wxImage_SetData(arg1,arg2,arg3);
15705 wxPyEndAllowThreads(__tstate);
15706 if (PyErr_Occurred()) SWIG_fail;
15707 }
15708 resultobj = SWIG_Py_Void();
15709 return resultobj;
15710 fail:
15711 return NULL;
15712 }
15713
15714
15715 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15716 PyObject *resultobj = 0;
15717 wxImage *arg1 = (wxImage *) 0 ;
15718 PyObject *result = 0 ;
15719 void *argp1 = 0 ;
15720 int res1 = 0 ;
15721 PyObject *swig_obj[1] ;
15722
15723 if (!args) SWIG_fail;
15724 swig_obj[0] = args;
15725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15726 if (!SWIG_IsOK(res1)) {
15727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15728 }
15729 arg1 = reinterpret_cast< wxImage * >(argp1);
15730 {
15731 PyThreadState* __tstate = wxPyBeginAllowThreads();
15732 result = (PyObject *)wxImage_GetDataBuffer(arg1);
15733 wxPyEndAllowThreads(__tstate);
15734 if (PyErr_Occurred()) SWIG_fail;
15735 }
15736 resultobj = result;
15737 return resultobj;
15738 fail:
15739 return NULL;
15740 }
15741
15742
15743 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15744 PyObject *resultobj = 0;
15745 wxImage *arg1 = (wxImage *) 0 ;
15746 buffer arg2 ;
15747 int arg3 ;
15748 void *argp1 = 0 ;
15749 int res1 = 0 ;
15750 Py_ssize_t temp2 ;
15751 PyObject * obj0 = 0 ;
15752 PyObject * obj1 = 0 ;
15753 char * kwnames[] = {
15754 (char *) "self",(char *) "data", NULL
15755 };
15756
15757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15759 if (!SWIG_IsOK(res1)) {
15760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15761 }
15762 arg1 = reinterpret_cast< wxImage * >(argp1);
15763 {
15764 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
15765 arg3 = (int)temp2;
15766 }
15767 {
15768 PyThreadState* __tstate = wxPyBeginAllowThreads();
15769 wxImage_SetDataBuffer(arg1,arg2,arg3);
15770 wxPyEndAllowThreads(__tstate);
15771 if (PyErr_Occurred()) SWIG_fail;
15772 }
15773 resultobj = SWIG_Py_Void();
15774 return resultobj;
15775 fail:
15776 return NULL;
15777 }
15778
15779
15780 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15781 PyObject *resultobj = 0;
15782 wxImage *arg1 = (wxImage *) 0 ;
15783 PyObject *result = 0 ;
15784 void *argp1 = 0 ;
15785 int res1 = 0 ;
15786 PyObject *swig_obj[1] ;
15787
15788 if (!args) SWIG_fail;
15789 swig_obj[0] = args;
15790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15791 if (!SWIG_IsOK(res1)) {
15792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15793 }
15794 arg1 = reinterpret_cast< wxImage * >(argp1);
15795 {
15796 PyThreadState* __tstate = wxPyBeginAllowThreads();
15797 result = (PyObject *)wxImage_GetAlphaData(arg1);
15798 wxPyEndAllowThreads(__tstate);
15799 if (PyErr_Occurred()) SWIG_fail;
15800 }
15801 resultobj = result;
15802 return resultobj;
15803 fail:
15804 return NULL;
15805 }
15806
15807
15808 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15809 PyObject *resultobj = 0;
15810 wxImage *arg1 = (wxImage *) 0 ;
15811 buffer arg2 ;
15812 int arg3 ;
15813 void *argp1 = 0 ;
15814 int res1 = 0 ;
15815 Py_ssize_t temp2 ;
15816 PyObject * obj0 = 0 ;
15817 PyObject * obj1 = 0 ;
15818 char * kwnames[] = {
15819 (char *) "self",(char *) "alpha", NULL
15820 };
15821
15822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
15823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15824 if (!SWIG_IsOK(res1)) {
15825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15826 }
15827 arg1 = reinterpret_cast< wxImage * >(argp1);
15828 {
15829 if (obj1 != Py_None) {
15830 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
15831 arg3 = (int)temp2;
15832 }
15833 }
15834 {
15835 PyThreadState* __tstate = wxPyBeginAllowThreads();
15836 wxImage_SetAlphaData(arg1,arg2,arg3);
15837 wxPyEndAllowThreads(__tstate);
15838 if (PyErr_Occurred()) SWIG_fail;
15839 }
15840 resultobj = SWIG_Py_Void();
15841 return resultobj;
15842 fail:
15843 return NULL;
15844 }
15845
15846
15847 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15848 PyObject *resultobj = 0;
15849 wxImage *arg1 = (wxImage *) 0 ;
15850 PyObject *result = 0 ;
15851 void *argp1 = 0 ;
15852 int res1 = 0 ;
15853 PyObject *swig_obj[1] ;
15854
15855 if (!args) SWIG_fail;
15856 swig_obj[0] = args;
15857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15858 if (!SWIG_IsOK(res1)) {
15859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15860 }
15861 arg1 = reinterpret_cast< wxImage * >(argp1);
15862 {
15863 PyThreadState* __tstate = wxPyBeginAllowThreads();
15864 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
15865 wxPyEndAllowThreads(__tstate);
15866 if (PyErr_Occurred()) SWIG_fail;
15867 }
15868 resultobj = result;
15869 return resultobj;
15870 fail:
15871 return NULL;
15872 }
15873
15874
15875 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15876 PyObject *resultobj = 0;
15877 wxImage *arg1 = (wxImage *) 0 ;
15878 buffer arg2 ;
15879 int arg3 ;
15880 void *argp1 = 0 ;
15881 int res1 = 0 ;
15882 Py_ssize_t temp2 ;
15883 PyObject * obj0 = 0 ;
15884 PyObject * obj1 = 0 ;
15885 char * kwnames[] = {
15886 (char *) "self",(char *) "alpha", NULL
15887 };
15888
15889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15891 if (!SWIG_IsOK(res1)) {
15892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15893 }
15894 arg1 = reinterpret_cast< wxImage * >(argp1);
15895 {
15896 if (obj1 != Py_None) {
15897 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
15898 arg3 = (int)temp2;
15899 }
15900 }
15901 {
15902 PyThreadState* __tstate = wxPyBeginAllowThreads();
15903 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
15904 wxPyEndAllowThreads(__tstate);
15905 if (PyErr_Occurred()) SWIG_fail;
15906 }
15907 resultobj = SWIG_Py_Void();
15908 return resultobj;
15909 fail:
15910 return NULL;
15911 }
15912
15913
15914 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15915 PyObject *resultobj = 0;
15916 wxImage *arg1 = (wxImage *) 0 ;
15917 byte arg2 ;
15918 byte arg3 ;
15919 byte arg4 ;
15920 void *argp1 = 0 ;
15921 int res1 = 0 ;
15922 unsigned char val2 ;
15923 int ecode2 = 0 ;
15924 unsigned char val3 ;
15925 int ecode3 = 0 ;
15926 unsigned char val4 ;
15927 int ecode4 = 0 ;
15928 PyObject * obj0 = 0 ;
15929 PyObject * obj1 = 0 ;
15930 PyObject * obj2 = 0 ;
15931 PyObject * obj3 = 0 ;
15932 char * kwnames[] = {
15933 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15934 };
15935
15936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15938 if (!SWIG_IsOK(res1)) {
15939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
15940 }
15941 arg1 = reinterpret_cast< wxImage * >(argp1);
15942 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15943 if (!SWIG_IsOK(ecode2)) {
15944 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
15945 }
15946 arg2 = static_cast< byte >(val2);
15947 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15948 if (!SWIG_IsOK(ecode3)) {
15949 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
15950 }
15951 arg3 = static_cast< byte >(val3);
15952 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15953 if (!SWIG_IsOK(ecode4)) {
15954 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
15955 }
15956 arg4 = static_cast< byte >(val4);
15957 {
15958 PyThreadState* __tstate = wxPyBeginAllowThreads();
15959 (arg1)->SetMaskColour(arg2,arg3,arg4);
15960 wxPyEndAllowThreads(__tstate);
15961 if (PyErr_Occurred()) SWIG_fail;
15962 }
15963 resultobj = SWIG_Py_Void();
15964 return resultobj;
15965 fail:
15966 return NULL;
15967 }
15968
15969
15970 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15971 PyObject *resultobj = 0;
15972 wxImage *arg1 = (wxImage *) 0 ;
15973 byte *arg2 = (byte *) 0 ;
15974 byte *arg3 = (byte *) 0 ;
15975 byte *arg4 = (byte *) 0 ;
15976 void *argp1 = 0 ;
15977 int res1 = 0 ;
15978 byte temp2 ;
15979 int res2 = SWIG_TMPOBJ ;
15980 byte temp3 ;
15981 int res3 = SWIG_TMPOBJ ;
15982 byte temp4 ;
15983 int res4 = SWIG_TMPOBJ ;
15984 PyObject *swig_obj[1] ;
15985
15986 arg2 = &temp2;
15987 arg3 = &temp3;
15988 arg4 = &temp4;
15989 if (!args) SWIG_fail;
15990 swig_obj[0] = args;
15991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15992 if (!SWIG_IsOK(res1)) {
15993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
15994 }
15995 arg1 = reinterpret_cast< wxImage * >(argp1);
15996 {
15997 PyThreadState* __tstate = wxPyBeginAllowThreads();
15998 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
15999 wxPyEndAllowThreads(__tstate);
16000 if (PyErr_Occurred()) SWIG_fail;
16001 }
16002 resultobj = SWIG_Py_Void();
16003 if (SWIG_IsTmpObj(res2)) {
16004 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
16005 } else {
16006 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16007 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
16008 }
16009 if (SWIG_IsTmpObj(res3)) {
16010 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
16011 } else {
16012 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16013 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
16014 }
16015 if (SWIG_IsTmpObj(res4)) {
16016 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
16017 } else {
16018 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
16019 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
16020 }
16021 return resultobj;
16022 fail:
16023 return NULL;
16024 }
16025
16026
16027 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16028 PyObject *resultobj = 0;
16029 wxImage *arg1 = (wxImage *) 0 ;
16030 byte result;
16031 void *argp1 = 0 ;
16032 int res1 = 0 ;
16033 PyObject *swig_obj[1] ;
16034
16035 if (!args) SWIG_fail;
16036 swig_obj[0] = args;
16037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16038 if (!SWIG_IsOK(res1)) {
16039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
16040 }
16041 arg1 = reinterpret_cast< wxImage * >(argp1);
16042 {
16043 PyThreadState* __tstate = wxPyBeginAllowThreads();
16044 result = (byte)(arg1)->GetMaskRed();
16045 wxPyEndAllowThreads(__tstate);
16046 if (PyErr_Occurred()) SWIG_fail;
16047 }
16048 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16049 return resultobj;
16050 fail:
16051 return NULL;
16052 }
16053
16054
16055 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16056 PyObject *resultobj = 0;
16057 wxImage *arg1 = (wxImage *) 0 ;
16058 byte result;
16059 void *argp1 = 0 ;
16060 int res1 = 0 ;
16061 PyObject *swig_obj[1] ;
16062
16063 if (!args) SWIG_fail;
16064 swig_obj[0] = args;
16065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16066 if (!SWIG_IsOK(res1)) {
16067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
16068 }
16069 arg1 = reinterpret_cast< wxImage * >(argp1);
16070 {
16071 PyThreadState* __tstate = wxPyBeginAllowThreads();
16072 result = (byte)(arg1)->GetMaskGreen();
16073 wxPyEndAllowThreads(__tstate);
16074 if (PyErr_Occurred()) SWIG_fail;
16075 }
16076 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16077 return resultobj;
16078 fail:
16079 return NULL;
16080 }
16081
16082
16083 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16084 PyObject *resultobj = 0;
16085 wxImage *arg1 = (wxImage *) 0 ;
16086 byte result;
16087 void *argp1 = 0 ;
16088 int res1 = 0 ;
16089 PyObject *swig_obj[1] ;
16090
16091 if (!args) SWIG_fail;
16092 swig_obj[0] = args;
16093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16094 if (!SWIG_IsOK(res1)) {
16095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
16096 }
16097 arg1 = reinterpret_cast< wxImage * >(argp1);
16098 {
16099 PyThreadState* __tstate = wxPyBeginAllowThreads();
16100 result = (byte)(arg1)->GetMaskBlue();
16101 wxPyEndAllowThreads(__tstate);
16102 if (PyErr_Occurred()) SWIG_fail;
16103 }
16104 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16105 return resultobj;
16106 fail:
16107 return NULL;
16108 }
16109
16110
16111 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16112 PyObject *resultobj = 0;
16113 wxImage *arg1 = (wxImage *) 0 ;
16114 bool arg2 = (bool) true ;
16115 void *argp1 = 0 ;
16116 int res1 = 0 ;
16117 bool val2 ;
16118 int ecode2 = 0 ;
16119 PyObject * obj0 = 0 ;
16120 PyObject * obj1 = 0 ;
16121 char * kwnames[] = {
16122 (char *) "self",(char *) "mask", NULL
16123 };
16124
16125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
16126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16127 if (!SWIG_IsOK(res1)) {
16128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
16129 }
16130 arg1 = reinterpret_cast< wxImage * >(argp1);
16131 if (obj1) {
16132 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16133 if (!SWIG_IsOK(ecode2)) {
16134 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
16135 }
16136 arg2 = static_cast< bool >(val2);
16137 }
16138 {
16139 PyThreadState* __tstate = wxPyBeginAllowThreads();
16140 (arg1)->SetMask(arg2);
16141 wxPyEndAllowThreads(__tstate);
16142 if (PyErr_Occurred()) SWIG_fail;
16143 }
16144 resultobj = SWIG_Py_Void();
16145 return resultobj;
16146 fail:
16147 return NULL;
16148 }
16149
16150
16151 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16152 PyObject *resultobj = 0;
16153 wxImage *arg1 = (wxImage *) 0 ;
16154 bool result;
16155 void *argp1 = 0 ;
16156 int res1 = 0 ;
16157 PyObject *swig_obj[1] ;
16158
16159 if (!args) SWIG_fail;
16160 swig_obj[0] = args;
16161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16162 if (!SWIG_IsOK(res1)) {
16163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
16164 }
16165 arg1 = reinterpret_cast< wxImage * >(argp1);
16166 {
16167 PyThreadState* __tstate = wxPyBeginAllowThreads();
16168 result = (bool)(arg1)->HasMask();
16169 wxPyEndAllowThreads(__tstate);
16170 if (PyErr_Occurred()) SWIG_fail;
16171 }
16172 {
16173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16174 }
16175 return resultobj;
16176 fail:
16177 return NULL;
16178 }
16179
16180
16181 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16182 PyObject *resultobj = 0;
16183 wxImage *arg1 = (wxImage *) 0 ;
16184 double arg2 ;
16185 wxPoint *arg3 = 0 ;
16186 bool arg4 = (bool) true ;
16187 wxPoint *arg5 = (wxPoint *) NULL ;
16188 SwigValueWrapper<wxImage > result;
16189 void *argp1 = 0 ;
16190 int res1 = 0 ;
16191 double val2 ;
16192 int ecode2 = 0 ;
16193 wxPoint temp3 ;
16194 bool val4 ;
16195 int ecode4 = 0 ;
16196 void *argp5 = 0 ;
16197 int res5 = 0 ;
16198 PyObject * obj0 = 0 ;
16199 PyObject * obj1 = 0 ;
16200 PyObject * obj2 = 0 ;
16201 PyObject * obj3 = 0 ;
16202 PyObject * obj4 = 0 ;
16203 char * kwnames[] = {
16204 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
16205 };
16206
16207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16209 if (!SWIG_IsOK(res1)) {
16210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
16211 }
16212 arg1 = reinterpret_cast< wxImage * >(argp1);
16213 ecode2 = SWIG_AsVal_double(obj1, &val2);
16214 if (!SWIG_IsOK(ecode2)) {
16215 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
16216 }
16217 arg2 = static_cast< double >(val2);
16218 {
16219 arg3 = &temp3;
16220 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
16221 }
16222 if (obj3) {
16223 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16224 if (!SWIG_IsOK(ecode4)) {
16225 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
16226 }
16227 arg4 = static_cast< bool >(val4);
16228 }
16229 if (obj4) {
16230 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
16231 if (!SWIG_IsOK(res5)) {
16232 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
16233 }
16234 arg5 = reinterpret_cast< wxPoint * >(argp5);
16235 }
16236 {
16237 PyThreadState* __tstate = wxPyBeginAllowThreads();
16238 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
16239 wxPyEndAllowThreads(__tstate);
16240 if (PyErr_Occurred()) SWIG_fail;
16241 }
16242 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16243 return resultobj;
16244 fail:
16245 return NULL;
16246 }
16247
16248
16249 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16250 PyObject *resultobj = 0;
16251 wxImage *arg1 = (wxImage *) 0 ;
16252 bool arg2 = (bool) true ;
16253 SwigValueWrapper<wxImage > result;
16254 void *argp1 = 0 ;
16255 int res1 = 0 ;
16256 bool val2 ;
16257 int ecode2 = 0 ;
16258 PyObject * obj0 = 0 ;
16259 PyObject * obj1 = 0 ;
16260 char * kwnames[] = {
16261 (char *) "self",(char *) "clockwise", NULL
16262 };
16263
16264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
16265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16266 if (!SWIG_IsOK(res1)) {
16267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
16268 }
16269 arg1 = reinterpret_cast< wxImage * >(argp1);
16270 if (obj1) {
16271 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16272 if (!SWIG_IsOK(ecode2)) {
16273 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
16274 }
16275 arg2 = static_cast< bool >(val2);
16276 }
16277 {
16278 PyThreadState* __tstate = wxPyBeginAllowThreads();
16279 result = (arg1)->Rotate90(arg2);
16280 wxPyEndAllowThreads(__tstate);
16281 if (PyErr_Occurred()) SWIG_fail;
16282 }
16283 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16284 return resultobj;
16285 fail:
16286 return NULL;
16287 }
16288
16289
16290 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16291 PyObject *resultobj = 0;
16292 wxImage *arg1 = (wxImage *) 0 ;
16293 bool arg2 = (bool) true ;
16294 SwigValueWrapper<wxImage > result;
16295 void *argp1 = 0 ;
16296 int res1 = 0 ;
16297 bool val2 ;
16298 int ecode2 = 0 ;
16299 PyObject * obj0 = 0 ;
16300 PyObject * obj1 = 0 ;
16301 char * kwnames[] = {
16302 (char *) "self",(char *) "horizontally", NULL
16303 };
16304
16305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
16306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16307 if (!SWIG_IsOK(res1)) {
16308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
16309 }
16310 arg1 = reinterpret_cast< wxImage * >(argp1);
16311 if (obj1) {
16312 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16313 if (!SWIG_IsOK(ecode2)) {
16314 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
16315 }
16316 arg2 = static_cast< bool >(val2);
16317 }
16318 {
16319 PyThreadState* __tstate = wxPyBeginAllowThreads();
16320 result = (arg1)->Mirror(arg2);
16321 wxPyEndAllowThreads(__tstate);
16322 if (PyErr_Occurred()) SWIG_fail;
16323 }
16324 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16325 return resultobj;
16326 fail:
16327 return NULL;
16328 }
16329
16330
16331 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16332 PyObject *resultobj = 0;
16333 wxImage *arg1 = (wxImage *) 0 ;
16334 byte arg2 ;
16335 byte arg3 ;
16336 byte arg4 ;
16337 byte arg5 ;
16338 byte arg6 ;
16339 byte arg7 ;
16340 void *argp1 = 0 ;
16341 int res1 = 0 ;
16342 unsigned char val2 ;
16343 int ecode2 = 0 ;
16344 unsigned char val3 ;
16345 int ecode3 = 0 ;
16346 unsigned char val4 ;
16347 int ecode4 = 0 ;
16348 unsigned char val5 ;
16349 int ecode5 = 0 ;
16350 unsigned char val6 ;
16351 int ecode6 = 0 ;
16352 unsigned char val7 ;
16353 int ecode7 = 0 ;
16354 PyObject * obj0 = 0 ;
16355 PyObject * obj1 = 0 ;
16356 PyObject * obj2 = 0 ;
16357 PyObject * obj3 = 0 ;
16358 PyObject * obj4 = 0 ;
16359 PyObject * obj5 = 0 ;
16360 PyObject * obj6 = 0 ;
16361 char * kwnames[] = {
16362 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
16363 };
16364
16365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
16366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16367 if (!SWIG_IsOK(res1)) {
16368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
16369 }
16370 arg1 = reinterpret_cast< wxImage * >(argp1);
16371 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16372 if (!SWIG_IsOK(ecode2)) {
16373 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
16374 }
16375 arg2 = static_cast< byte >(val2);
16376 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16377 if (!SWIG_IsOK(ecode3)) {
16378 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
16379 }
16380 arg3 = static_cast< byte >(val3);
16381 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16382 if (!SWIG_IsOK(ecode4)) {
16383 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
16384 }
16385 arg4 = static_cast< byte >(val4);
16386 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16387 if (!SWIG_IsOK(ecode5)) {
16388 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
16389 }
16390 arg5 = static_cast< byte >(val5);
16391 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16392 if (!SWIG_IsOK(ecode6)) {
16393 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16394 }
16395 arg6 = static_cast< byte >(val6);
16396 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16397 if (!SWIG_IsOK(ecode7)) {
16398 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16399 }
16400 arg7 = static_cast< byte >(val7);
16401 {
16402 PyThreadState* __tstate = wxPyBeginAllowThreads();
16403 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16404 wxPyEndAllowThreads(__tstate);
16405 if (PyErr_Occurred()) SWIG_fail;
16406 }
16407 resultobj = SWIG_Py_Void();
16408 return resultobj;
16409 fail:
16410 return NULL;
16411 }
16412
16413
16414 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16415 PyObject *resultobj = 0;
16416 wxImage *arg1 = (wxImage *) 0 ;
16417 double arg2 = (double) 0.299 ;
16418 double arg3 = (double) 0.587 ;
16419 double arg4 = (double) 0.114 ;
16420 SwigValueWrapper<wxImage > result;
16421 void *argp1 = 0 ;
16422 int res1 = 0 ;
16423 double val2 ;
16424 int ecode2 = 0 ;
16425 double val3 ;
16426 int ecode3 = 0 ;
16427 double val4 ;
16428 int ecode4 = 0 ;
16429 PyObject * obj0 = 0 ;
16430 PyObject * obj1 = 0 ;
16431 PyObject * obj2 = 0 ;
16432 PyObject * obj3 = 0 ;
16433 char * kwnames[] = {
16434 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16435 };
16436
16437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16439 if (!SWIG_IsOK(res1)) {
16440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16441 }
16442 arg1 = reinterpret_cast< wxImage * >(argp1);
16443 if (obj1) {
16444 ecode2 = SWIG_AsVal_double(obj1, &val2);
16445 if (!SWIG_IsOK(ecode2)) {
16446 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16447 }
16448 arg2 = static_cast< double >(val2);
16449 }
16450 if (obj2) {
16451 ecode3 = SWIG_AsVal_double(obj2, &val3);
16452 if (!SWIG_IsOK(ecode3)) {
16453 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16454 }
16455 arg3 = static_cast< double >(val3);
16456 }
16457 if (obj3) {
16458 ecode4 = SWIG_AsVal_double(obj3, &val4);
16459 if (!SWIG_IsOK(ecode4)) {
16460 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16461 }
16462 arg4 = static_cast< double >(val4);
16463 }
16464 {
16465 PyThreadState* __tstate = wxPyBeginAllowThreads();
16466 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16467 wxPyEndAllowThreads(__tstate);
16468 if (PyErr_Occurred()) SWIG_fail;
16469 }
16470 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16471 return resultobj;
16472 fail:
16473 return NULL;
16474 }
16475
16476
16477 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16478 PyObject *resultobj = 0;
16479 wxImage *arg1 = (wxImage *) 0 ;
16480 byte arg2 ;
16481 byte arg3 ;
16482 byte arg4 ;
16483 SwigValueWrapper<wxImage > result;
16484 void *argp1 = 0 ;
16485 int res1 = 0 ;
16486 unsigned char val2 ;
16487 int ecode2 = 0 ;
16488 unsigned char val3 ;
16489 int ecode3 = 0 ;
16490 unsigned char val4 ;
16491 int ecode4 = 0 ;
16492 PyObject * obj0 = 0 ;
16493 PyObject * obj1 = 0 ;
16494 PyObject * obj2 = 0 ;
16495 PyObject * obj3 = 0 ;
16496 char * kwnames[] = {
16497 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16498 };
16499
16500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16502 if (!SWIG_IsOK(res1)) {
16503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16504 }
16505 arg1 = reinterpret_cast< wxImage * >(argp1);
16506 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16507 if (!SWIG_IsOK(ecode2)) {
16508 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16509 }
16510 arg2 = static_cast< byte >(val2);
16511 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16512 if (!SWIG_IsOK(ecode3)) {
16513 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16514 }
16515 arg3 = static_cast< byte >(val3);
16516 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16517 if (!SWIG_IsOK(ecode4)) {
16518 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16519 }
16520 arg4 = static_cast< byte >(val4);
16521 {
16522 PyThreadState* __tstate = wxPyBeginAllowThreads();
16523 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16524 wxPyEndAllowThreads(__tstate);
16525 if (PyErr_Occurred()) SWIG_fail;
16526 }
16527 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16528 return resultobj;
16529 fail:
16530 return NULL;
16531 }
16532
16533
16534 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16535 PyObject *resultobj = 0;
16536 wxImage *arg1 = (wxImage *) 0 ;
16537 wxString *arg2 = 0 ;
16538 wxString *arg3 = 0 ;
16539 void *argp1 = 0 ;
16540 int res1 = 0 ;
16541 bool temp2 = false ;
16542 bool temp3 = false ;
16543 PyObject * obj0 = 0 ;
16544 PyObject * obj1 = 0 ;
16545 PyObject * obj2 = 0 ;
16546 char * kwnames[] = {
16547 (char *) "self",(char *) "name",(char *) "value", NULL
16548 };
16549
16550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16552 if (!SWIG_IsOK(res1)) {
16553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16554 }
16555 arg1 = reinterpret_cast< wxImage * >(argp1);
16556 {
16557 arg2 = wxString_in_helper(obj1);
16558 if (arg2 == NULL) SWIG_fail;
16559 temp2 = true;
16560 }
16561 {
16562 arg3 = wxString_in_helper(obj2);
16563 if (arg3 == NULL) SWIG_fail;
16564 temp3 = true;
16565 }
16566 {
16567 PyThreadState* __tstate = wxPyBeginAllowThreads();
16568 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16569 wxPyEndAllowThreads(__tstate);
16570 if (PyErr_Occurred()) SWIG_fail;
16571 }
16572 resultobj = SWIG_Py_Void();
16573 {
16574 if (temp2)
16575 delete arg2;
16576 }
16577 {
16578 if (temp3)
16579 delete arg3;
16580 }
16581 return resultobj;
16582 fail:
16583 {
16584 if (temp2)
16585 delete arg2;
16586 }
16587 {
16588 if (temp3)
16589 delete arg3;
16590 }
16591 return NULL;
16592 }
16593
16594
16595 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16596 PyObject *resultobj = 0;
16597 wxImage *arg1 = (wxImage *) 0 ;
16598 wxString *arg2 = 0 ;
16599 int arg3 ;
16600 void *argp1 = 0 ;
16601 int res1 = 0 ;
16602 bool temp2 = false ;
16603 int val3 ;
16604 int ecode3 = 0 ;
16605 PyObject * obj0 = 0 ;
16606 PyObject * obj1 = 0 ;
16607 PyObject * obj2 = 0 ;
16608 char * kwnames[] = {
16609 (char *) "self",(char *) "name",(char *) "value", NULL
16610 };
16611
16612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16614 if (!SWIG_IsOK(res1)) {
16615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16616 }
16617 arg1 = reinterpret_cast< wxImage * >(argp1);
16618 {
16619 arg2 = wxString_in_helper(obj1);
16620 if (arg2 == NULL) SWIG_fail;
16621 temp2 = true;
16622 }
16623 ecode3 = SWIG_AsVal_int(obj2, &val3);
16624 if (!SWIG_IsOK(ecode3)) {
16625 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16626 }
16627 arg3 = static_cast< int >(val3);
16628 {
16629 PyThreadState* __tstate = wxPyBeginAllowThreads();
16630 (arg1)->SetOption((wxString const &)*arg2,arg3);
16631 wxPyEndAllowThreads(__tstate);
16632 if (PyErr_Occurred()) SWIG_fail;
16633 }
16634 resultobj = SWIG_Py_Void();
16635 {
16636 if (temp2)
16637 delete arg2;
16638 }
16639 return resultobj;
16640 fail:
16641 {
16642 if (temp2)
16643 delete arg2;
16644 }
16645 return NULL;
16646 }
16647
16648
16649 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16650 PyObject *resultobj = 0;
16651 wxImage *arg1 = (wxImage *) 0 ;
16652 wxString *arg2 = 0 ;
16653 wxString result;
16654 void *argp1 = 0 ;
16655 int res1 = 0 ;
16656 bool temp2 = false ;
16657 PyObject * obj0 = 0 ;
16658 PyObject * obj1 = 0 ;
16659 char * kwnames[] = {
16660 (char *) "self",(char *) "name", NULL
16661 };
16662
16663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16665 if (!SWIG_IsOK(res1)) {
16666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16667 }
16668 arg1 = reinterpret_cast< wxImage * >(argp1);
16669 {
16670 arg2 = wxString_in_helper(obj1);
16671 if (arg2 == NULL) SWIG_fail;
16672 temp2 = true;
16673 }
16674 {
16675 PyThreadState* __tstate = wxPyBeginAllowThreads();
16676 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16677 wxPyEndAllowThreads(__tstate);
16678 if (PyErr_Occurred()) SWIG_fail;
16679 }
16680 {
16681 #if wxUSE_UNICODE
16682 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16683 #else
16684 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16685 #endif
16686 }
16687 {
16688 if (temp2)
16689 delete arg2;
16690 }
16691 return resultobj;
16692 fail:
16693 {
16694 if (temp2)
16695 delete arg2;
16696 }
16697 return NULL;
16698 }
16699
16700
16701 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16702 PyObject *resultobj = 0;
16703 wxImage *arg1 = (wxImage *) 0 ;
16704 wxString *arg2 = 0 ;
16705 int result;
16706 void *argp1 = 0 ;
16707 int res1 = 0 ;
16708 bool temp2 = false ;
16709 PyObject * obj0 = 0 ;
16710 PyObject * obj1 = 0 ;
16711 char * kwnames[] = {
16712 (char *) "self",(char *) "name", NULL
16713 };
16714
16715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
16716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16717 if (!SWIG_IsOK(res1)) {
16718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
16719 }
16720 arg1 = reinterpret_cast< wxImage * >(argp1);
16721 {
16722 arg2 = wxString_in_helper(obj1);
16723 if (arg2 == NULL) SWIG_fail;
16724 temp2 = true;
16725 }
16726 {
16727 PyThreadState* __tstate = wxPyBeginAllowThreads();
16728 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
16729 wxPyEndAllowThreads(__tstate);
16730 if (PyErr_Occurred()) SWIG_fail;
16731 }
16732 resultobj = SWIG_From_int(static_cast< int >(result));
16733 {
16734 if (temp2)
16735 delete arg2;
16736 }
16737 return resultobj;
16738 fail:
16739 {
16740 if (temp2)
16741 delete arg2;
16742 }
16743 return NULL;
16744 }
16745
16746
16747 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16748 PyObject *resultobj = 0;
16749 wxImage *arg1 = (wxImage *) 0 ;
16750 wxString *arg2 = 0 ;
16751 bool result;
16752 void *argp1 = 0 ;
16753 int res1 = 0 ;
16754 bool temp2 = false ;
16755 PyObject * obj0 = 0 ;
16756 PyObject * obj1 = 0 ;
16757 char * kwnames[] = {
16758 (char *) "self",(char *) "name", NULL
16759 };
16760
16761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
16762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16763 if (!SWIG_IsOK(res1)) {
16764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16765 }
16766 arg1 = reinterpret_cast< wxImage * >(argp1);
16767 {
16768 arg2 = wxString_in_helper(obj1);
16769 if (arg2 == NULL) SWIG_fail;
16770 temp2 = true;
16771 }
16772 {
16773 PyThreadState* __tstate = wxPyBeginAllowThreads();
16774 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
16775 wxPyEndAllowThreads(__tstate);
16776 if (PyErr_Occurred()) SWIG_fail;
16777 }
16778 {
16779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16780 }
16781 {
16782 if (temp2)
16783 delete arg2;
16784 }
16785 return resultobj;
16786 fail:
16787 {
16788 if (temp2)
16789 delete arg2;
16790 }
16791 return NULL;
16792 }
16793
16794
16795 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16796 PyObject *resultobj = 0;
16797 wxImage *arg1 = (wxImage *) 0 ;
16798 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
16799 unsigned long result;
16800 void *argp1 = 0 ;
16801 int res1 = 0 ;
16802 unsigned long val2 ;
16803 int ecode2 = 0 ;
16804 PyObject * obj0 = 0 ;
16805 PyObject * obj1 = 0 ;
16806 char * kwnames[] = {
16807 (char *) "self",(char *) "stopafter", NULL
16808 };
16809
16810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
16811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16812 if (!SWIG_IsOK(res1)) {
16813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
16814 }
16815 arg1 = reinterpret_cast< wxImage * >(argp1);
16816 if (obj1) {
16817 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
16818 if (!SWIG_IsOK(ecode2)) {
16819 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
16820 }
16821 arg2 = static_cast< unsigned long >(val2);
16822 }
16823 {
16824 PyThreadState* __tstate = wxPyBeginAllowThreads();
16825 result = (unsigned long)(arg1)->CountColours(arg2);
16826 wxPyEndAllowThreads(__tstate);
16827 if (PyErr_Occurred()) SWIG_fail;
16828 }
16829 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16830 return resultobj;
16831 fail:
16832 return NULL;
16833 }
16834
16835
16836 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16837 PyObject *resultobj = 0;
16838 wxImage *arg1 = (wxImage *) 0 ;
16839 wxImageHistogram *arg2 = 0 ;
16840 unsigned long result;
16841 void *argp1 = 0 ;
16842 int res1 = 0 ;
16843 void *argp2 = 0 ;
16844 int res2 = 0 ;
16845 PyObject * obj0 = 0 ;
16846 PyObject * obj1 = 0 ;
16847 char * kwnames[] = {
16848 (char *) "self",(char *) "h", NULL
16849 };
16850
16851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
16852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16853 if (!SWIG_IsOK(res1)) {
16854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
16855 }
16856 arg1 = reinterpret_cast< wxImage * >(argp1);
16857 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
16858 if (!SWIG_IsOK(res2)) {
16859 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16860 }
16861 if (!argp2) {
16862 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16863 }
16864 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
16865 {
16866 PyThreadState* __tstate = wxPyBeginAllowThreads();
16867 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
16868 wxPyEndAllowThreads(__tstate);
16869 if (PyErr_Occurred()) SWIG_fail;
16870 }
16871 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16872 return resultobj;
16873 fail:
16874 return NULL;
16875 }
16876
16877
16878 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16879 PyObject *resultobj = 0;
16880 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16881 void *argp1 = 0 ;
16882 int res1 = 0 ;
16883 PyObject * obj0 = 0 ;
16884 char * kwnames[] = {
16885 (char *) "handler", NULL
16886 };
16887
16888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
16889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16890 if (!SWIG_IsOK(res1)) {
16891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16892 }
16893 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16894 {
16895 PyThreadState* __tstate = wxPyBeginAllowThreads();
16896 wxImage::AddHandler(arg1);
16897 wxPyEndAllowThreads(__tstate);
16898 if (PyErr_Occurred()) SWIG_fail;
16899 }
16900 resultobj = SWIG_Py_Void();
16901 return resultobj;
16902 fail:
16903 return NULL;
16904 }
16905
16906
16907 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16908 PyObject *resultobj = 0;
16909 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16910 void *argp1 = 0 ;
16911 int res1 = 0 ;
16912 PyObject * obj0 = 0 ;
16913 char * kwnames[] = {
16914 (char *) "handler", NULL
16915 };
16916
16917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
16918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16919 if (!SWIG_IsOK(res1)) {
16920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16921 }
16922 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16923 {
16924 PyThreadState* __tstate = wxPyBeginAllowThreads();
16925 wxImage::InsertHandler(arg1);
16926 wxPyEndAllowThreads(__tstate);
16927 if (PyErr_Occurred()) SWIG_fail;
16928 }
16929 resultobj = SWIG_Py_Void();
16930 return resultobj;
16931 fail:
16932 return NULL;
16933 }
16934
16935
16936 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16937 PyObject *resultobj = 0;
16938 wxString *arg1 = 0 ;
16939 bool result;
16940 bool temp1 = false ;
16941 PyObject * obj0 = 0 ;
16942 char * kwnames[] = {
16943 (char *) "name", NULL
16944 };
16945
16946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
16947 {
16948 arg1 = wxString_in_helper(obj0);
16949 if (arg1 == NULL) SWIG_fail;
16950 temp1 = true;
16951 }
16952 {
16953 PyThreadState* __tstate = wxPyBeginAllowThreads();
16954 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
16955 wxPyEndAllowThreads(__tstate);
16956 if (PyErr_Occurred()) SWIG_fail;
16957 }
16958 {
16959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16960 }
16961 {
16962 if (temp1)
16963 delete arg1;
16964 }
16965 return resultobj;
16966 fail:
16967 {
16968 if (temp1)
16969 delete arg1;
16970 }
16971 return NULL;
16972 }
16973
16974
16975 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16976 PyObject *resultobj = 0;
16977 PyObject *result = 0 ;
16978
16979 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
16980 {
16981 PyThreadState* __tstate = wxPyBeginAllowThreads();
16982 result = (PyObject *)wxImage_GetHandlers();
16983 wxPyEndAllowThreads(__tstate);
16984 if (PyErr_Occurred()) SWIG_fail;
16985 }
16986 resultobj = result;
16987 return resultobj;
16988 fail:
16989 return NULL;
16990 }
16991
16992
16993 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16994 PyObject *resultobj = 0;
16995 wxString result;
16996
16997 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
16998 {
16999 PyThreadState* __tstate = wxPyBeginAllowThreads();
17000 result = wxImage::GetImageExtWildcard();
17001 wxPyEndAllowThreads(__tstate);
17002 if (PyErr_Occurred()) SWIG_fail;
17003 }
17004 {
17005 #if wxUSE_UNICODE
17006 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
17007 #else
17008 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
17009 #endif
17010 }
17011 return resultobj;
17012 fail:
17013 return NULL;
17014 }
17015
17016
17017 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17018 PyObject *resultobj = 0;
17019 wxImage *arg1 = (wxImage *) 0 ;
17020 int arg2 = (int) -1 ;
17021 wxBitmap result;
17022 void *argp1 = 0 ;
17023 int res1 = 0 ;
17024 int val2 ;
17025 int ecode2 = 0 ;
17026 PyObject * obj0 = 0 ;
17027 PyObject * obj1 = 0 ;
17028 char * kwnames[] = {
17029 (char *) "self",(char *) "depth", NULL
17030 };
17031
17032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
17033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17034 if (!SWIG_IsOK(res1)) {
17035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
17036 }
17037 arg1 = reinterpret_cast< wxImage * >(argp1);
17038 if (obj1) {
17039 ecode2 = SWIG_AsVal_int(obj1, &val2);
17040 if (!SWIG_IsOK(ecode2)) {
17041 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
17042 }
17043 arg2 = static_cast< int >(val2);
17044 }
17045 {
17046 if (!wxPyCheckForApp()) SWIG_fail;
17047 PyThreadState* __tstate = wxPyBeginAllowThreads();
17048 result = wxImage_ConvertToBitmap(arg1,arg2);
17049 wxPyEndAllowThreads(__tstate);
17050 if (PyErr_Occurred()) SWIG_fail;
17051 }
17052 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
17053 return resultobj;
17054 fail:
17055 return NULL;
17056 }
17057
17058
17059 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17060 PyObject *resultobj = 0;
17061 wxImage *arg1 = (wxImage *) 0 ;
17062 byte arg2 ;
17063 byte arg3 ;
17064 byte arg4 ;
17065 wxBitmap result;
17066 void *argp1 = 0 ;
17067 int res1 = 0 ;
17068 unsigned char val2 ;
17069 int ecode2 = 0 ;
17070 unsigned char val3 ;
17071 int ecode3 = 0 ;
17072 unsigned char val4 ;
17073 int ecode4 = 0 ;
17074 PyObject * obj0 = 0 ;
17075 PyObject * obj1 = 0 ;
17076 PyObject * obj2 = 0 ;
17077 PyObject * obj3 = 0 ;
17078 char * kwnames[] = {
17079 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
17080 };
17081
17082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17084 if (!SWIG_IsOK(res1)) {
17085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
17086 }
17087 arg1 = reinterpret_cast< wxImage * >(argp1);
17088 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17089 if (!SWIG_IsOK(ecode2)) {
17090 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
17091 }
17092 arg2 = static_cast< byte >(val2);
17093 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17094 if (!SWIG_IsOK(ecode3)) {
17095 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
17096 }
17097 arg3 = static_cast< byte >(val3);
17098 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17099 if (!SWIG_IsOK(ecode4)) {
17100 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
17101 }
17102 arg4 = static_cast< byte >(val4);
17103 {
17104 if (!wxPyCheckForApp()) SWIG_fail;
17105 PyThreadState* __tstate = wxPyBeginAllowThreads();
17106 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
17107 wxPyEndAllowThreads(__tstate);
17108 if (PyErr_Occurred()) SWIG_fail;
17109 }
17110 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
17111 return resultobj;
17112 fail:
17113 return NULL;
17114 }
17115
17116
17117 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17118 PyObject *resultobj = 0;
17119 wxImage *arg1 = (wxImage *) 0 ;
17120 double arg2 ;
17121 void *argp1 = 0 ;
17122 int res1 = 0 ;
17123 double val2 ;
17124 int ecode2 = 0 ;
17125 PyObject * obj0 = 0 ;
17126 PyObject * obj1 = 0 ;
17127 char * kwnames[] = {
17128 (char *) "self",(char *) "angle", NULL
17129 };
17130
17131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
17132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17133 if (!SWIG_IsOK(res1)) {
17134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
17135 }
17136 arg1 = reinterpret_cast< wxImage * >(argp1);
17137 ecode2 = SWIG_AsVal_double(obj1, &val2);
17138 if (!SWIG_IsOK(ecode2)) {
17139 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
17140 }
17141 arg2 = static_cast< double >(val2);
17142 {
17143 PyThreadState* __tstate = wxPyBeginAllowThreads();
17144 (arg1)->RotateHue(arg2);
17145 wxPyEndAllowThreads(__tstate);
17146 if (PyErr_Occurred()) SWIG_fail;
17147 }
17148 resultobj = SWIG_Py_Void();
17149 return resultobj;
17150 fail:
17151 return NULL;
17152 }
17153
17154
17155 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17156 PyObject *resultobj = 0;
17157 wxImage_RGBValue arg1 ;
17158 wxImage_HSVValue result;
17159 void *argp1 ;
17160 int res1 = 0 ;
17161 PyObject * obj0 = 0 ;
17162 char * kwnames[] = {
17163 (char *) "rgb", NULL
17164 };
17165
17166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
17167 {
17168 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
17169 if (!SWIG_IsOK(res1)) {
17170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
17171 }
17172 if (!argp1) {
17173 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
17174 } else {
17175 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
17176 arg1 = *temp;
17177 if (SWIG_IsNewObj(res1)) delete temp;
17178 }
17179 }
17180 {
17181 PyThreadState* __tstate = wxPyBeginAllowThreads();
17182 result = wxImage::RGBtoHSV(arg1);
17183 wxPyEndAllowThreads(__tstate);
17184 if (PyErr_Occurred()) SWIG_fail;
17185 }
17186 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
17187 return resultobj;
17188 fail:
17189 return NULL;
17190 }
17191
17192
17193 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17194 PyObject *resultobj = 0;
17195 wxImage_HSVValue arg1 ;
17196 wxImage_RGBValue result;
17197 void *argp1 ;
17198 int res1 = 0 ;
17199 PyObject * obj0 = 0 ;
17200 char * kwnames[] = {
17201 (char *) "hsv", NULL
17202 };
17203
17204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
17205 {
17206 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
17207 if (!SWIG_IsOK(res1)) {
17208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
17209 }
17210 if (!argp1) {
17211 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
17212 } else {
17213 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
17214 arg1 = *temp;
17215 if (SWIG_IsNewObj(res1)) delete temp;
17216 }
17217 }
17218 {
17219 PyThreadState* __tstate = wxPyBeginAllowThreads();
17220 result = wxImage::HSVtoRGB(arg1);
17221 wxPyEndAllowThreads(__tstate);
17222 if (PyErr_Occurred()) SWIG_fail;
17223 }
17224 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
17225 return resultobj;
17226 fail:
17227 return NULL;
17228 }
17229
17230
17231 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17232 PyObject *obj;
17233 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17234 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
17235 return SWIG_Py_Void();
17236 }
17237
17238 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17239 return SWIG_Python_InitShadowInstance(args);
17240 }
17241
17242 SWIGINTERN PyObject *_wrap__ImageFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17243 PyObject *resultobj = 0;
17244 int arg1 ;
17245 int arg2 ;
17246 buffer arg3 ;
17247 int arg4 ;
17248 buffer arg5 = (buffer) NULL ;
17249 int arg6 = (int) 0 ;
17250 wxImage *result = 0 ;
17251 int val1 ;
17252 int ecode1 = 0 ;
17253 int val2 ;
17254 int ecode2 = 0 ;
17255 Py_ssize_t temp3 ;
17256 Py_ssize_t temp5 ;
17257 PyObject * obj0 = 0 ;
17258 PyObject * obj1 = 0 ;
17259 PyObject * obj2 = 0 ;
17260 PyObject * obj3 = 0 ;
17261 char * kwnames[] = {
17262 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
17263 };
17264
17265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:_ImageFromBuffer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17266 ecode1 = SWIG_AsVal_int(obj0, &val1);
17267 if (!SWIG_IsOK(ecode1)) {
17268 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_ImageFromBuffer" "', expected argument " "1"" of type '" "int""'");
17269 }
17270 arg1 = static_cast< int >(val1);
17271 ecode2 = SWIG_AsVal_int(obj1, &val2);
17272 if (!SWIG_IsOK(ecode2)) {
17273 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ImageFromBuffer" "', expected argument " "2"" of type '" "int""'");
17274 }
17275 arg2 = static_cast< int >(val2);
17276 {
17277 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
17278 arg4 = (int)temp3;
17279 }
17280 if (obj3) {
17281 {
17282 if (obj3 != Py_None) {
17283 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
17284 arg6 = (int)temp5;
17285 }
17286 }
17287 }
17288 {
17289 PyThreadState* __tstate = wxPyBeginAllowThreads();
17290 result = (wxImage *)_ImageFromBuffer(arg1,arg2,arg3,arg4,arg5,arg6);
17291 wxPyEndAllowThreads(__tstate);
17292 if (PyErr_Occurred()) SWIG_fail;
17293 }
17294 {
17295 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
17296 }
17297 return resultobj;
17298 fail:
17299 return NULL;
17300 }
17301
17302
17303 SWIGINTERN int NullImage_set(PyObject *) {
17304 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
17305 return 1;
17306 }
17307
17308
17309 SWIGINTERN PyObject *NullImage_get(void) {
17310 PyObject *pyobj = 0;
17311
17312 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
17313 return pyobj;
17314 }
17315
17316
17317 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
17318 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
17319 return 1;
17320 }
17321
17322
17323 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
17324 PyObject *pyobj = 0;
17325
17326 {
17327 #if wxUSE_UNICODE
17328 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17329 #else
17330 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17331 #endif
17332 }
17333 return pyobj;
17334 }
17335
17336
17337 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
17338 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
17339 return 1;
17340 }
17341
17342
17343 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
17344 PyObject *pyobj = 0;
17345
17346 {
17347 #if wxUSE_UNICODE
17348 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17349 #else
17350 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17351 #endif
17352 }
17353 return pyobj;
17354 }
17355
17356
17357 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
17358 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
17359 return 1;
17360 }
17361
17362
17363 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
17364 PyObject *pyobj = 0;
17365
17366 {
17367 #if wxUSE_UNICODE
17368 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17369 #else
17370 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17371 #endif
17372 }
17373 return pyobj;
17374 }
17375
17376
17377 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
17378 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
17379 return 1;
17380 }
17381
17382
17383 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
17384 PyObject *pyobj = 0;
17385
17386 {
17387 #if wxUSE_UNICODE
17388 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17389 #else
17390 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17391 #endif
17392 }
17393 return pyobj;
17394 }
17395
17396
17397 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
17398 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
17399 return 1;
17400 }
17401
17402
17403 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
17404 PyObject *pyobj = 0;
17405
17406 {
17407 #if wxUSE_UNICODE
17408 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17409 #else
17410 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17411 #endif
17412 }
17413 return pyobj;
17414 }
17415
17416
17417 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
17418 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
17419 return 1;
17420 }
17421
17422
17423 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
17424 PyObject *pyobj = 0;
17425
17426 {
17427 #if wxUSE_UNICODE
17428 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17429 #else
17430 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17431 #endif
17432 }
17433 return pyobj;
17434 }
17435
17436
17437 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
17438 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
17439 return 1;
17440 }
17441
17442
17443 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
17444 PyObject *pyobj = 0;
17445
17446 {
17447 #if wxUSE_UNICODE
17448 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17449 #else
17450 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17451 #endif
17452 }
17453 return pyobj;
17454 }
17455
17456
17457 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17458 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17459 return 1;
17460 }
17461
17462
17463 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17464 PyObject *pyobj = 0;
17465
17466 {
17467 #if wxUSE_UNICODE
17468 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17469 #else
17470 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17471 #endif
17472 }
17473 return pyobj;
17474 }
17475
17476
17477 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17478 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17479 return 1;
17480 }
17481
17482
17483 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17484 PyObject *pyobj = 0;
17485
17486 {
17487 #if wxUSE_UNICODE
17488 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17489 #else
17490 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17491 #endif
17492 }
17493 return pyobj;
17494 }
17495
17496
17497 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17498 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17499 return 1;
17500 }
17501
17502
17503 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17504 PyObject *pyobj = 0;
17505
17506 {
17507 #if wxUSE_UNICODE
17508 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17509 #else
17510 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17511 #endif
17512 }
17513 return pyobj;
17514 }
17515
17516
17517 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17518 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17519 return 1;
17520 }
17521
17522
17523 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17524 PyObject *pyobj = 0;
17525
17526 {
17527 #if wxUSE_UNICODE
17528 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17529 #else
17530 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17531 #endif
17532 }
17533 return pyobj;
17534 }
17535
17536
17537 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17538 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17539 return 1;
17540 }
17541
17542
17543 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17544 PyObject *pyobj = 0;
17545
17546 {
17547 #if wxUSE_UNICODE
17548 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17549 #else
17550 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17551 #endif
17552 }
17553 return pyobj;
17554 }
17555
17556
17557 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17558 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17559 return 1;
17560 }
17561
17562
17563 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17564 PyObject *pyobj = 0;
17565
17566 {
17567 #if wxUSE_UNICODE
17568 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17569 #else
17570 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17571 #endif
17572 }
17573 return pyobj;
17574 }
17575
17576
17577 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17578 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17579 return 1;
17580 }
17581
17582
17583 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17584 PyObject *pyobj = 0;
17585
17586 {
17587 #if wxUSE_UNICODE
17588 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17589 #else
17590 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17591 #endif
17592 }
17593 return pyobj;
17594 }
17595
17596
17597 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17598 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17599 return 1;
17600 }
17601
17602
17603 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17604 PyObject *pyobj = 0;
17605
17606 {
17607 #if wxUSE_UNICODE
17608 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17609 #else
17610 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17611 #endif
17612 }
17613 return pyobj;
17614 }
17615
17616
17617 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17618 PyObject *resultobj = 0;
17619 wxBMPHandler *result = 0 ;
17620
17621 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17622 {
17623 PyThreadState* __tstate = wxPyBeginAllowThreads();
17624 result = (wxBMPHandler *)new wxBMPHandler();
17625 wxPyEndAllowThreads(__tstate);
17626 if (PyErr_Occurred()) SWIG_fail;
17627 }
17628 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17629 return resultobj;
17630 fail:
17631 return NULL;
17632 }
17633
17634
17635 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17636 PyObject *obj;
17637 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17638 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17639 return SWIG_Py_Void();
17640 }
17641
17642 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17643 return SWIG_Python_InitShadowInstance(args);
17644 }
17645
17646 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17647 PyObject *resultobj = 0;
17648 wxICOHandler *result = 0 ;
17649
17650 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17651 {
17652 PyThreadState* __tstate = wxPyBeginAllowThreads();
17653 result = (wxICOHandler *)new wxICOHandler();
17654 wxPyEndAllowThreads(__tstate);
17655 if (PyErr_Occurred()) SWIG_fail;
17656 }
17657 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17658 return resultobj;
17659 fail:
17660 return NULL;
17661 }
17662
17663
17664 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17665 PyObject *obj;
17666 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17667 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17668 return SWIG_Py_Void();
17669 }
17670
17671 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17672 return SWIG_Python_InitShadowInstance(args);
17673 }
17674
17675 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17676 PyObject *resultobj = 0;
17677 wxCURHandler *result = 0 ;
17678
17679 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17680 {
17681 PyThreadState* __tstate = wxPyBeginAllowThreads();
17682 result = (wxCURHandler *)new wxCURHandler();
17683 wxPyEndAllowThreads(__tstate);
17684 if (PyErr_Occurred()) SWIG_fail;
17685 }
17686 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
17687 return resultobj;
17688 fail:
17689 return NULL;
17690 }
17691
17692
17693 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17694 PyObject *obj;
17695 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17696 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
17697 return SWIG_Py_Void();
17698 }
17699
17700 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17701 return SWIG_Python_InitShadowInstance(args);
17702 }
17703
17704 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17705 PyObject *resultobj = 0;
17706 wxANIHandler *result = 0 ;
17707
17708 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
17709 {
17710 PyThreadState* __tstate = wxPyBeginAllowThreads();
17711 result = (wxANIHandler *)new wxANIHandler();
17712 wxPyEndAllowThreads(__tstate);
17713 if (PyErr_Occurred()) SWIG_fail;
17714 }
17715 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
17716 return resultobj;
17717 fail:
17718 return NULL;
17719 }
17720
17721
17722 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17723 PyObject *obj;
17724 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17725 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
17726 return SWIG_Py_Void();
17727 }
17728
17729 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17730 return SWIG_Python_InitShadowInstance(args);
17731 }
17732
17733 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17734 PyObject *resultobj = 0;
17735 wxPNGHandler *result = 0 ;
17736
17737 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
17738 {
17739 PyThreadState* __tstate = wxPyBeginAllowThreads();
17740 result = (wxPNGHandler *)new wxPNGHandler();
17741 wxPyEndAllowThreads(__tstate);
17742 if (PyErr_Occurred()) SWIG_fail;
17743 }
17744 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
17745 return resultobj;
17746 fail:
17747 return NULL;
17748 }
17749
17750
17751 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17752 PyObject *obj;
17753 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17754 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
17755 return SWIG_Py_Void();
17756 }
17757
17758 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17759 return SWIG_Python_InitShadowInstance(args);
17760 }
17761
17762 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17763 PyObject *resultobj = 0;
17764 wxGIFHandler *result = 0 ;
17765
17766 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
17767 {
17768 PyThreadState* __tstate = wxPyBeginAllowThreads();
17769 result = (wxGIFHandler *)new wxGIFHandler();
17770 wxPyEndAllowThreads(__tstate);
17771 if (PyErr_Occurred()) SWIG_fail;
17772 }
17773 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
17774 return resultobj;
17775 fail:
17776 return NULL;
17777 }
17778
17779
17780 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17781 PyObject *obj;
17782 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17783 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
17784 return SWIG_Py_Void();
17785 }
17786
17787 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17788 return SWIG_Python_InitShadowInstance(args);
17789 }
17790
17791 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17792 PyObject *resultobj = 0;
17793 wxPCXHandler *result = 0 ;
17794
17795 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
17796 {
17797 PyThreadState* __tstate = wxPyBeginAllowThreads();
17798 result = (wxPCXHandler *)new wxPCXHandler();
17799 wxPyEndAllowThreads(__tstate);
17800 if (PyErr_Occurred()) SWIG_fail;
17801 }
17802 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
17803 return resultobj;
17804 fail:
17805 return NULL;
17806 }
17807
17808
17809 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17810 PyObject *obj;
17811 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17812 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
17813 return SWIG_Py_Void();
17814 }
17815
17816 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17817 return SWIG_Python_InitShadowInstance(args);
17818 }
17819
17820 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17821 PyObject *resultobj = 0;
17822 wxJPEGHandler *result = 0 ;
17823
17824 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
17825 {
17826 PyThreadState* __tstate = wxPyBeginAllowThreads();
17827 result = (wxJPEGHandler *)new wxJPEGHandler();
17828 wxPyEndAllowThreads(__tstate);
17829 if (PyErr_Occurred()) SWIG_fail;
17830 }
17831 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
17832 return resultobj;
17833 fail:
17834 return NULL;
17835 }
17836
17837
17838 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17839 PyObject *obj;
17840 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17841 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
17842 return SWIG_Py_Void();
17843 }
17844
17845 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17846 return SWIG_Python_InitShadowInstance(args);
17847 }
17848
17849 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17850 PyObject *resultobj = 0;
17851 wxPNMHandler *result = 0 ;
17852
17853 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
17854 {
17855 PyThreadState* __tstate = wxPyBeginAllowThreads();
17856 result = (wxPNMHandler *)new wxPNMHandler();
17857 wxPyEndAllowThreads(__tstate);
17858 if (PyErr_Occurred()) SWIG_fail;
17859 }
17860 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
17861 return resultobj;
17862 fail:
17863 return NULL;
17864 }
17865
17866
17867 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17868 PyObject *obj;
17869 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17870 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
17871 return SWIG_Py_Void();
17872 }
17873
17874 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17875 return SWIG_Python_InitShadowInstance(args);
17876 }
17877
17878 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17879 PyObject *resultobj = 0;
17880 wxXPMHandler *result = 0 ;
17881
17882 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
17883 {
17884 PyThreadState* __tstate = wxPyBeginAllowThreads();
17885 result = (wxXPMHandler *)new wxXPMHandler();
17886 wxPyEndAllowThreads(__tstate);
17887 if (PyErr_Occurred()) SWIG_fail;
17888 }
17889 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
17890 return resultobj;
17891 fail:
17892 return NULL;
17893 }
17894
17895
17896 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17897 PyObject *obj;
17898 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17899 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
17900 return SWIG_Py_Void();
17901 }
17902
17903 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17904 return SWIG_Python_InitShadowInstance(args);
17905 }
17906
17907 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17908 PyObject *resultobj = 0;
17909 wxTIFFHandler *result = 0 ;
17910
17911 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
17912 {
17913 PyThreadState* __tstate = wxPyBeginAllowThreads();
17914 result = (wxTIFFHandler *)new wxTIFFHandler();
17915 wxPyEndAllowThreads(__tstate);
17916 if (PyErr_Occurred()) SWIG_fail;
17917 }
17918 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
17919 return resultobj;
17920 fail:
17921 return NULL;
17922 }
17923
17924
17925 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17926 PyObject *obj;
17927 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17928 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
17929 return SWIG_Py_Void();
17930 }
17931
17932 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17933 return SWIG_Python_InitShadowInstance(args);
17934 }
17935
17936 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17937 PyObject *resultobj = 0;
17938 wxImage *arg1 = 0 ;
17939 wxImage *arg2 = 0 ;
17940 int arg3 = (int) 236 ;
17941 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
17942 bool result;
17943 void *argp1 = 0 ;
17944 int res1 = 0 ;
17945 void *argp2 = 0 ;
17946 int res2 = 0 ;
17947 int val3 ;
17948 int ecode3 = 0 ;
17949 int val4 ;
17950 int ecode4 = 0 ;
17951 PyObject * obj0 = 0 ;
17952 PyObject * obj1 = 0 ;
17953 PyObject * obj2 = 0 ;
17954 PyObject * obj3 = 0 ;
17955 char * kwnames[] = {
17956 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
17957 };
17958
17959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17960 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
17961 if (!SWIG_IsOK(res1)) {
17962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17963 }
17964 if (!argp1) {
17965 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17966 }
17967 arg1 = reinterpret_cast< wxImage * >(argp1);
17968 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
17969 if (!SWIG_IsOK(res2)) {
17970 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17971 }
17972 if (!argp2) {
17973 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17974 }
17975 arg2 = reinterpret_cast< wxImage * >(argp2);
17976 if (obj2) {
17977 ecode3 = SWIG_AsVal_int(obj2, &val3);
17978 if (!SWIG_IsOK(ecode3)) {
17979 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
17980 }
17981 arg3 = static_cast< int >(val3);
17982 }
17983 if (obj3) {
17984 ecode4 = SWIG_AsVal_int(obj3, &val4);
17985 if (!SWIG_IsOK(ecode4)) {
17986 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
17987 }
17988 arg4 = static_cast< int >(val4);
17989 }
17990 {
17991 PyThreadState* __tstate = wxPyBeginAllowThreads();
17992 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
17993 wxPyEndAllowThreads(__tstate);
17994 if (PyErr_Occurred()) SWIG_fail;
17995 }
17996 {
17997 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17998 }
17999 return resultobj;
18000 fail:
18001 return NULL;
18002 }
18003
18004
18005 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18006 PyObject *obj;
18007 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18008 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
18009 return SWIG_Py_Void();
18010 }
18011
18012 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18013 PyObject *resultobj = 0;
18014 wxEvtHandler *result = 0 ;
18015
18016 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
18017 {
18018 PyThreadState* __tstate = wxPyBeginAllowThreads();
18019 result = (wxEvtHandler *)new wxEvtHandler();
18020 wxPyEndAllowThreads(__tstate);
18021 if (PyErr_Occurred()) SWIG_fail;
18022 }
18023 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
18024 return resultobj;
18025 fail:
18026 return NULL;
18027 }
18028
18029
18030 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18031 PyObject *resultobj = 0;
18032 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18033 wxEvtHandler *result = 0 ;
18034 void *argp1 = 0 ;
18035 int res1 = 0 ;
18036 PyObject *swig_obj[1] ;
18037
18038 if (!args) SWIG_fail;
18039 swig_obj[0] = args;
18040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18041 if (!SWIG_IsOK(res1)) {
18042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18043 }
18044 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18045 {
18046 PyThreadState* __tstate = wxPyBeginAllowThreads();
18047 result = (wxEvtHandler *)(arg1)->GetNextHandler();
18048 wxPyEndAllowThreads(__tstate);
18049 if (PyErr_Occurred()) SWIG_fail;
18050 }
18051 {
18052 resultobj = wxPyMake_wxObject(result, 0);
18053 }
18054 return resultobj;
18055 fail:
18056 return NULL;
18057 }
18058
18059
18060 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18061 PyObject *resultobj = 0;
18062 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18063 wxEvtHandler *result = 0 ;
18064 void *argp1 = 0 ;
18065 int res1 = 0 ;
18066 PyObject *swig_obj[1] ;
18067
18068 if (!args) SWIG_fail;
18069 swig_obj[0] = args;
18070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18071 if (!SWIG_IsOK(res1)) {
18072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18073 }
18074 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18075 {
18076 PyThreadState* __tstate = wxPyBeginAllowThreads();
18077 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
18078 wxPyEndAllowThreads(__tstate);
18079 if (PyErr_Occurred()) SWIG_fail;
18080 }
18081 {
18082 resultobj = wxPyMake_wxObject(result, 0);
18083 }
18084 return resultobj;
18085 fail:
18086 return NULL;
18087 }
18088
18089
18090 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18091 PyObject *resultobj = 0;
18092 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18093 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
18094 void *argp1 = 0 ;
18095 int res1 = 0 ;
18096 void *argp2 = 0 ;
18097 int res2 = 0 ;
18098 PyObject * obj0 = 0 ;
18099 PyObject * obj1 = 0 ;
18100 char * kwnames[] = {
18101 (char *) "self",(char *) "handler", NULL
18102 };
18103
18104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
18105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18106 if (!SWIG_IsOK(res1)) {
18107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18108 }
18109 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18110 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18111 if (!SWIG_IsOK(res2)) {
18112 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
18113 }
18114 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
18115 {
18116 PyThreadState* __tstate = wxPyBeginAllowThreads();
18117 (arg1)->SetNextHandler(arg2);
18118 wxPyEndAllowThreads(__tstate);
18119 if (PyErr_Occurred()) SWIG_fail;
18120 }
18121 resultobj = SWIG_Py_Void();
18122 return resultobj;
18123 fail:
18124 return NULL;
18125 }
18126
18127
18128 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18129 PyObject *resultobj = 0;
18130 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18131 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
18132 void *argp1 = 0 ;
18133 int res1 = 0 ;
18134 void *argp2 = 0 ;
18135 int res2 = 0 ;
18136 PyObject * obj0 = 0 ;
18137 PyObject * obj1 = 0 ;
18138 char * kwnames[] = {
18139 (char *) "self",(char *) "handler", NULL
18140 };
18141
18142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
18143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18144 if (!SWIG_IsOK(res1)) {
18145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18146 }
18147 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18148 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18149 if (!SWIG_IsOK(res2)) {
18150 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
18151 }
18152 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
18153 {
18154 PyThreadState* __tstate = wxPyBeginAllowThreads();
18155 (arg1)->SetPreviousHandler(arg2);
18156 wxPyEndAllowThreads(__tstate);
18157 if (PyErr_Occurred()) SWIG_fail;
18158 }
18159 resultobj = SWIG_Py_Void();
18160 return resultobj;
18161 fail:
18162 return NULL;
18163 }
18164
18165
18166 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18167 PyObject *resultobj = 0;
18168 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18169 bool result;
18170 void *argp1 = 0 ;
18171 int res1 = 0 ;
18172 PyObject *swig_obj[1] ;
18173
18174 if (!args) SWIG_fail;
18175 swig_obj[0] = args;
18176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18177 if (!SWIG_IsOK(res1)) {
18178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18179 }
18180 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18181 {
18182 PyThreadState* __tstate = wxPyBeginAllowThreads();
18183 result = (bool)(arg1)->GetEvtHandlerEnabled();
18184 wxPyEndAllowThreads(__tstate);
18185 if (PyErr_Occurred()) SWIG_fail;
18186 }
18187 {
18188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18189 }
18190 return resultobj;
18191 fail:
18192 return NULL;
18193 }
18194
18195
18196 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18197 PyObject *resultobj = 0;
18198 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18199 bool arg2 ;
18200 void *argp1 = 0 ;
18201 int res1 = 0 ;
18202 bool val2 ;
18203 int ecode2 = 0 ;
18204 PyObject * obj0 = 0 ;
18205 PyObject * obj1 = 0 ;
18206 char * kwnames[] = {
18207 (char *) "self",(char *) "enabled", NULL
18208 };
18209
18210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
18211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18212 if (!SWIG_IsOK(res1)) {
18213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18214 }
18215 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18216 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18217 if (!SWIG_IsOK(ecode2)) {
18218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
18219 }
18220 arg2 = static_cast< bool >(val2);
18221 {
18222 PyThreadState* __tstate = wxPyBeginAllowThreads();
18223 (arg1)->SetEvtHandlerEnabled(arg2);
18224 wxPyEndAllowThreads(__tstate);
18225 if (PyErr_Occurred()) SWIG_fail;
18226 }
18227 resultobj = SWIG_Py_Void();
18228 return resultobj;
18229 fail:
18230 return NULL;
18231 }
18232
18233
18234 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18235 PyObject *resultobj = 0;
18236 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18237 wxEvent *arg2 = 0 ;
18238 bool result;
18239 void *argp1 = 0 ;
18240 int res1 = 0 ;
18241 void *argp2 = 0 ;
18242 int res2 = 0 ;
18243 PyObject * obj0 = 0 ;
18244 PyObject * obj1 = 0 ;
18245 char * kwnames[] = {
18246 (char *) "self",(char *) "event", NULL
18247 };
18248
18249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18251 if (!SWIG_IsOK(res1)) {
18252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18253 }
18254 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18255 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
18256 if (!SWIG_IsOK(res2)) {
18257 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18258 }
18259 if (!argp2) {
18260 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18261 }
18262 arg2 = reinterpret_cast< wxEvent * >(argp2);
18263 {
18264 PyThreadState* __tstate = wxPyBeginAllowThreads();
18265 result = (bool)(arg1)->ProcessEvent(*arg2);
18266 wxPyEndAllowThreads(__tstate);
18267 if (PyErr_Occurred()) SWIG_fail;
18268 }
18269 {
18270 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18271 }
18272 return resultobj;
18273 fail:
18274 return NULL;
18275 }
18276
18277
18278 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18279 PyObject *resultobj = 0;
18280 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18281 wxEvent *arg2 = 0 ;
18282 void *argp1 = 0 ;
18283 int res1 = 0 ;
18284 void *argp2 = 0 ;
18285 int res2 = 0 ;
18286 PyObject * obj0 = 0 ;
18287 PyObject * obj1 = 0 ;
18288 char * kwnames[] = {
18289 (char *) "self",(char *) "event", NULL
18290 };
18291
18292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18294 if (!SWIG_IsOK(res1)) {
18295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18296 }
18297 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18298 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
18299 if (!SWIG_IsOK(res2)) {
18300 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18301 }
18302 if (!argp2) {
18303 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18304 }
18305 arg2 = reinterpret_cast< wxEvent * >(argp2);
18306 {
18307 PyThreadState* __tstate = wxPyBeginAllowThreads();
18308 (arg1)->AddPendingEvent(*arg2);
18309 wxPyEndAllowThreads(__tstate);
18310 if (PyErr_Occurred()) SWIG_fail;
18311 }
18312 resultobj = SWIG_Py_Void();
18313 return resultobj;
18314 fail:
18315 return NULL;
18316 }
18317
18318
18319 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18320 PyObject *resultobj = 0;
18321 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18322 void *argp1 = 0 ;
18323 int res1 = 0 ;
18324 PyObject *swig_obj[1] ;
18325
18326 if (!args) SWIG_fail;
18327 swig_obj[0] = args;
18328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18329 if (!SWIG_IsOK(res1)) {
18330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18331 }
18332 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18333 {
18334 PyThreadState* __tstate = wxPyBeginAllowThreads();
18335 (arg1)->ProcessPendingEvents();
18336 wxPyEndAllowThreads(__tstate);
18337 if (PyErr_Occurred()) SWIG_fail;
18338 }
18339 resultobj = SWIG_Py_Void();
18340 return resultobj;
18341 fail:
18342 return NULL;
18343 }
18344
18345
18346 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18347 PyObject *resultobj = 0;
18348 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18349 int arg2 ;
18350 int arg3 ;
18351 int arg4 ;
18352 PyObject *arg5 = (PyObject *) 0 ;
18353 void *argp1 = 0 ;
18354 int res1 = 0 ;
18355 int val2 ;
18356 int ecode2 = 0 ;
18357 int val3 ;
18358 int ecode3 = 0 ;
18359 int val4 ;
18360 int ecode4 = 0 ;
18361 PyObject * obj0 = 0 ;
18362 PyObject * obj1 = 0 ;
18363 PyObject * obj2 = 0 ;
18364 PyObject * obj3 = 0 ;
18365 PyObject * obj4 = 0 ;
18366 char * kwnames[] = {
18367 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
18368 };
18369
18370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18372 if (!SWIG_IsOK(res1)) {
18373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18374 }
18375 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18376 ecode2 = SWIG_AsVal_int(obj1, &val2);
18377 if (!SWIG_IsOK(ecode2)) {
18378 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
18379 }
18380 arg2 = static_cast< int >(val2);
18381 ecode3 = SWIG_AsVal_int(obj2, &val3);
18382 if (!SWIG_IsOK(ecode3)) {
18383 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
18384 }
18385 arg3 = static_cast< int >(val3);
18386 ecode4 = SWIG_AsVal_int(obj3, &val4);
18387 if (!SWIG_IsOK(ecode4)) {
18388 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
18389 }
18390 arg4 = static_cast< int >(val4);
18391 arg5 = obj4;
18392 {
18393 PyThreadState* __tstate = wxPyBeginAllowThreads();
18394 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
18395 wxPyEndAllowThreads(__tstate);
18396 if (PyErr_Occurred()) SWIG_fail;
18397 }
18398 resultobj = SWIG_Py_Void();
18399 return resultobj;
18400 fail:
18401 return NULL;
18402 }
18403
18404
18405 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18406 PyObject *resultobj = 0;
18407 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18408 int arg2 ;
18409 int arg3 = (int) -1 ;
18410 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
18411 bool result;
18412 void *argp1 = 0 ;
18413 int res1 = 0 ;
18414 int val2 ;
18415 int ecode2 = 0 ;
18416 int val3 ;
18417 int ecode3 = 0 ;
18418 int val4 ;
18419 int ecode4 = 0 ;
18420 PyObject * obj0 = 0 ;
18421 PyObject * obj1 = 0 ;
18422 PyObject * obj2 = 0 ;
18423 PyObject * obj3 = 0 ;
18424 char * kwnames[] = {
18425 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
18426 };
18427
18428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18430 if (!SWIG_IsOK(res1)) {
18431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18432 }
18433 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18434 ecode2 = SWIG_AsVal_int(obj1, &val2);
18435 if (!SWIG_IsOK(ecode2)) {
18436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
18437 }
18438 arg2 = static_cast< int >(val2);
18439 if (obj2) {
18440 ecode3 = SWIG_AsVal_int(obj2, &val3);
18441 if (!SWIG_IsOK(ecode3)) {
18442 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
18443 }
18444 arg3 = static_cast< int >(val3);
18445 }
18446 if (obj3) {
18447 ecode4 = SWIG_AsVal_int(obj3, &val4);
18448 if (!SWIG_IsOK(ecode4)) {
18449 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
18450 }
18451 arg4 = static_cast< wxEventType >(val4);
18452 }
18453 {
18454 PyThreadState* __tstate = wxPyBeginAllowThreads();
18455 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18456 wxPyEndAllowThreads(__tstate);
18457 if (PyErr_Occurred()) SWIG_fail;
18458 }
18459 {
18460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18461 }
18462 return resultobj;
18463 fail:
18464 return NULL;
18465 }
18466
18467
18468 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18469 PyObject *resultobj = 0;
18470 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18471 PyObject *arg2 = (PyObject *) 0 ;
18472 bool arg3 = (bool) true ;
18473 void *argp1 = 0 ;
18474 int res1 = 0 ;
18475 bool val3 ;
18476 int ecode3 = 0 ;
18477 PyObject * obj0 = 0 ;
18478 PyObject * obj1 = 0 ;
18479 PyObject * obj2 = 0 ;
18480 char * kwnames[] = {
18481 (char *) "self",(char *) "_self",(char *) "incref", NULL
18482 };
18483
18484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18486 if (!SWIG_IsOK(res1)) {
18487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18488 }
18489 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18490 arg2 = obj1;
18491 if (obj2) {
18492 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18493 if (!SWIG_IsOK(ecode3)) {
18494 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18495 }
18496 arg3 = static_cast< bool >(val3);
18497 }
18498 {
18499 PyThreadState* __tstate = wxPyBeginAllowThreads();
18500 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18501 wxPyEndAllowThreads(__tstate);
18502 if (PyErr_Occurred()) SWIG_fail;
18503 }
18504 resultobj = SWIG_Py_Void();
18505 return resultobj;
18506 fail:
18507 return NULL;
18508 }
18509
18510
18511 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18512 PyObject *obj;
18513 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18514 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18515 return SWIG_Py_Void();
18516 }
18517
18518 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18519 return SWIG_Python_InitShadowInstance(args);
18520 }
18521
18522 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18523 PyObject *resultobj = 0;
18524 wxEventType result;
18525
18526 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18527 {
18528 PyThreadState* __tstate = wxPyBeginAllowThreads();
18529 result = (wxEventType)wxNewEventType();
18530 wxPyEndAllowThreads(__tstate);
18531 if (PyErr_Occurred()) SWIG_fail;
18532 }
18533 resultobj = SWIG_From_int(static_cast< int >(result));
18534 return resultobj;
18535 fail:
18536 return NULL;
18537 }
18538
18539
18540 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18541 PyObject *resultobj = 0;
18542 wxEvent *arg1 = (wxEvent *) 0 ;
18543 void *argp1 = 0 ;
18544 int res1 = 0 ;
18545 PyObject *swig_obj[1] ;
18546
18547 if (!args) SWIG_fail;
18548 swig_obj[0] = args;
18549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18550 if (!SWIG_IsOK(res1)) {
18551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18552 }
18553 arg1 = reinterpret_cast< wxEvent * >(argp1);
18554 {
18555 PyThreadState* __tstate = wxPyBeginAllowThreads();
18556 delete arg1;
18557
18558 wxPyEndAllowThreads(__tstate);
18559 if (PyErr_Occurred()) SWIG_fail;
18560 }
18561 resultobj = SWIG_Py_Void();
18562 return resultobj;
18563 fail:
18564 return NULL;
18565 }
18566
18567
18568 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18569 PyObject *resultobj = 0;
18570 wxEvent *arg1 = (wxEvent *) 0 ;
18571 wxEventType arg2 ;
18572 void *argp1 = 0 ;
18573 int res1 = 0 ;
18574 int val2 ;
18575 int ecode2 = 0 ;
18576 PyObject * obj0 = 0 ;
18577 PyObject * obj1 = 0 ;
18578 char * kwnames[] = {
18579 (char *) "self",(char *) "typ", NULL
18580 };
18581
18582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18584 if (!SWIG_IsOK(res1)) {
18585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18586 }
18587 arg1 = reinterpret_cast< wxEvent * >(argp1);
18588 ecode2 = SWIG_AsVal_int(obj1, &val2);
18589 if (!SWIG_IsOK(ecode2)) {
18590 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18591 }
18592 arg2 = static_cast< wxEventType >(val2);
18593 {
18594 PyThreadState* __tstate = wxPyBeginAllowThreads();
18595 (arg1)->SetEventType(arg2);
18596 wxPyEndAllowThreads(__tstate);
18597 if (PyErr_Occurred()) SWIG_fail;
18598 }
18599 resultobj = SWIG_Py_Void();
18600 return resultobj;
18601 fail:
18602 return NULL;
18603 }
18604
18605
18606 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18607 PyObject *resultobj = 0;
18608 wxEvent *arg1 = (wxEvent *) 0 ;
18609 wxEventType result;
18610 void *argp1 = 0 ;
18611 int res1 = 0 ;
18612 PyObject *swig_obj[1] ;
18613
18614 if (!args) SWIG_fail;
18615 swig_obj[0] = args;
18616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18617 if (!SWIG_IsOK(res1)) {
18618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18619 }
18620 arg1 = reinterpret_cast< wxEvent * >(argp1);
18621 {
18622 PyThreadState* __tstate = wxPyBeginAllowThreads();
18623 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18624 wxPyEndAllowThreads(__tstate);
18625 if (PyErr_Occurred()) SWIG_fail;
18626 }
18627 resultobj = SWIG_From_int(static_cast< int >(result));
18628 return resultobj;
18629 fail:
18630 return NULL;
18631 }
18632
18633
18634 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18635 PyObject *resultobj = 0;
18636 wxEvent *arg1 = (wxEvent *) 0 ;
18637 wxObject *result = 0 ;
18638 void *argp1 = 0 ;
18639 int res1 = 0 ;
18640 PyObject *swig_obj[1] ;
18641
18642 if (!args) SWIG_fail;
18643 swig_obj[0] = args;
18644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18645 if (!SWIG_IsOK(res1)) {
18646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18647 }
18648 arg1 = reinterpret_cast< wxEvent * >(argp1);
18649 {
18650 PyThreadState* __tstate = wxPyBeginAllowThreads();
18651 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18652 wxPyEndAllowThreads(__tstate);
18653 if (PyErr_Occurred()) SWIG_fail;
18654 }
18655 {
18656 resultobj = wxPyMake_wxObject(result, (bool)0);
18657 }
18658 return resultobj;
18659 fail:
18660 return NULL;
18661 }
18662
18663
18664 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18665 PyObject *resultobj = 0;
18666 wxEvent *arg1 = (wxEvent *) 0 ;
18667 wxObject *arg2 = (wxObject *) 0 ;
18668 void *argp1 = 0 ;
18669 int res1 = 0 ;
18670 void *argp2 = 0 ;
18671 int res2 = 0 ;
18672 PyObject * obj0 = 0 ;
18673 PyObject * obj1 = 0 ;
18674 char * kwnames[] = {
18675 (char *) "self",(char *) "obj", NULL
18676 };
18677
18678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18680 if (!SWIG_IsOK(res1)) {
18681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18682 }
18683 arg1 = reinterpret_cast< wxEvent * >(argp1);
18684 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18685 if (!SWIG_IsOK(res2)) {
18686 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
18687 }
18688 arg2 = reinterpret_cast< wxObject * >(argp2);
18689 {
18690 PyThreadState* __tstate = wxPyBeginAllowThreads();
18691 (arg1)->SetEventObject(arg2);
18692 wxPyEndAllowThreads(__tstate);
18693 if (PyErr_Occurred()) SWIG_fail;
18694 }
18695 resultobj = SWIG_Py_Void();
18696 return resultobj;
18697 fail:
18698 return NULL;
18699 }
18700
18701
18702 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18703 PyObject *resultobj = 0;
18704 wxEvent *arg1 = (wxEvent *) 0 ;
18705 long result;
18706 void *argp1 = 0 ;
18707 int res1 = 0 ;
18708 PyObject *swig_obj[1] ;
18709
18710 if (!args) SWIG_fail;
18711 swig_obj[0] = args;
18712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18713 if (!SWIG_IsOK(res1)) {
18714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
18715 }
18716 arg1 = reinterpret_cast< wxEvent * >(argp1);
18717 {
18718 PyThreadState* __tstate = wxPyBeginAllowThreads();
18719 result = (long)((wxEvent const *)arg1)->GetTimestamp();
18720 wxPyEndAllowThreads(__tstate);
18721 if (PyErr_Occurred()) SWIG_fail;
18722 }
18723 resultobj = SWIG_From_long(static_cast< long >(result));
18724 return resultobj;
18725 fail:
18726 return NULL;
18727 }
18728
18729
18730 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18731 PyObject *resultobj = 0;
18732 wxEvent *arg1 = (wxEvent *) 0 ;
18733 long arg2 = (long) 0 ;
18734 void *argp1 = 0 ;
18735 int res1 = 0 ;
18736 long val2 ;
18737 int ecode2 = 0 ;
18738 PyObject * obj0 = 0 ;
18739 PyObject * obj1 = 0 ;
18740 char * kwnames[] = {
18741 (char *) "self",(char *) "ts", NULL
18742 };
18743
18744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
18745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18746 if (!SWIG_IsOK(res1)) {
18747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
18748 }
18749 arg1 = reinterpret_cast< wxEvent * >(argp1);
18750 if (obj1) {
18751 ecode2 = SWIG_AsVal_long(obj1, &val2);
18752 if (!SWIG_IsOK(ecode2)) {
18753 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
18754 }
18755 arg2 = static_cast< long >(val2);
18756 }
18757 {
18758 PyThreadState* __tstate = wxPyBeginAllowThreads();
18759 (arg1)->SetTimestamp(arg2);
18760 wxPyEndAllowThreads(__tstate);
18761 if (PyErr_Occurred()) SWIG_fail;
18762 }
18763 resultobj = SWIG_Py_Void();
18764 return resultobj;
18765 fail:
18766 return NULL;
18767 }
18768
18769
18770 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18771 PyObject *resultobj = 0;
18772 wxEvent *arg1 = (wxEvent *) 0 ;
18773 int result;
18774 void *argp1 = 0 ;
18775 int res1 = 0 ;
18776 PyObject *swig_obj[1] ;
18777
18778 if (!args) SWIG_fail;
18779 swig_obj[0] = args;
18780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18781 if (!SWIG_IsOK(res1)) {
18782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
18783 }
18784 arg1 = reinterpret_cast< wxEvent * >(argp1);
18785 {
18786 PyThreadState* __tstate = wxPyBeginAllowThreads();
18787 result = (int)((wxEvent const *)arg1)->GetId();
18788 wxPyEndAllowThreads(__tstate);
18789 if (PyErr_Occurred()) SWIG_fail;
18790 }
18791 resultobj = SWIG_From_int(static_cast< int >(result));
18792 return resultobj;
18793 fail:
18794 return NULL;
18795 }
18796
18797
18798 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18799 PyObject *resultobj = 0;
18800 wxEvent *arg1 = (wxEvent *) 0 ;
18801 int arg2 ;
18802 void *argp1 = 0 ;
18803 int res1 = 0 ;
18804 int val2 ;
18805 int ecode2 = 0 ;
18806 PyObject * obj0 = 0 ;
18807 PyObject * obj1 = 0 ;
18808 char * kwnames[] = {
18809 (char *) "self",(char *) "Id", NULL
18810 };
18811
18812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
18813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18814 if (!SWIG_IsOK(res1)) {
18815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
18816 }
18817 arg1 = reinterpret_cast< wxEvent * >(argp1);
18818 ecode2 = SWIG_AsVal_int(obj1, &val2);
18819 if (!SWIG_IsOK(ecode2)) {
18820 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
18821 }
18822 arg2 = static_cast< int >(val2);
18823 {
18824 PyThreadState* __tstate = wxPyBeginAllowThreads();
18825 (arg1)->SetId(arg2);
18826 wxPyEndAllowThreads(__tstate);
18827 if (PyErr_Occurred()) SWIG_fail;
18828 }
18829 resultobj = SWIG_Py_Void();
18830 return resultobj;
18831 fail:
18832 return NULL;
18833 }
18834
18835
18836 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18837 PyObject *resultobj = 0;
18838 wxEvent *arg1 = (wxEvent *) 0 ;
18839 bool result;
18840 void *argp1 = 0 ;
18841 int res1 = 0 ;
18842 PyObject *swig_obj[1] ;
18843
18844 if (!args) SWIG_fail;
18845 swig_obj[0] = args;
18846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18847 if (!SWIG_IsOK(res1)) {
18848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
18849 }
18850 arg1 = reinterpret_cast< wxEvent * >(argp1);
18851 {
18852 PyThreadState* __tstate = wxPyBeginAllowThreads();
18853 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
18854 wxPyEndAllowThreads(__tstate);
18855 if (PyErr_Occurred()) SWIG_fail;
18856 }
18857 {
18858 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18859 }
18860 return resultobj;
18861 fail:
18862 return NULL;
18863 }
18864
18865
18866 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18867 PyObject *resultobj = 0;
18868 wxEvent *arg1 = (wxEvent *) 0 ;
18869 bool arg2 = (bool) true ;
18870 void *argp1 = 0 ;
18871 int res1 = 0 ;
18872 bool val2 ;
18873 int ecode2 = 0 ;
18874 PyObject * obj0 = 0 ;
18875 PyObject * obj1 = 0 ;
18876 char * kwnames[] = {
18877 (char *) "self",(char *) "skip", NULL
18878 };
18879
18880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
18881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18882 if (!SWIG_IsOK(res1)) {
18883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
18884 }
18885 arg1 = reinterpret_cast< wxEvent * >(argp1);
18886 if (obj1) {
18887 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18888 if (!SWIG_IsOK(ecode2)) {
18889 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
18890 }
18891 arg2 = static_cast< bool >(val2);
18892 }
18893 {
18894 PyThreadState* __tstate = wxPyBeginAllowThreads();
18895 (arg1)->Skip(arg2);
18896 wxPyEndAllowThreads(__tstate);
18897 if (PyErr_Occurred()) SWIG_fail;
18898 }
18899 resultobj = SWIG_Py_Void();
18900 return resultobj;
18901 fail:
18902 return NULL;
18903 }
18904
18905
18906 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18907 PyObject *resultobj = 0;
18908 wxEvent *arg1 = (wxEvent *) 0 ;
18909 bool result;
18910 void *argp1 = 0 ;
18911 int res1 = 0 ;
18912 PyObject *swig_obj[1] ;
18913
18914 if (!args) SWIG_fail;
18915 swig_obj[0] = args;
18916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18917 if (!SWIG_IsOK(res1)) {
18918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
18919 }
18920 arg1 = reinterpret_cast< wxEvent * >(argp1);
18921 {
18922 PyThreadState* __tstate = wxPyBeginAllowThreads();
18923 result = (bool)((wxEvent const *)arg1)->GetSkipped();
18924 wxPyEndAllowThreads(__tstate);
18925 if (PyErr_Occurred()) SWIG_fail;
18926 }
18927 {
18928 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18929 }
18930 return resultobj;
18931 fail:
18932 return NULL;
18933 }
18934
18935
18936 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18937 PyObject *resultobj = 0;
18938 wxEvent *arg1 = (wxEvent *) 0 ;
18939 bool result;
18940 void *argp1 = 0 ;
18941 int res1 = 0 ;
18942 PyObject *swig_obj[1] ;
18943
18944 if (!args) SWIG_fail;
18945 swig_obj[0] = args;
18946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18947 if (!SWIG_IsOK(res1)) {
18948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
18949 }
18950 arg1 = reinterpret_cast< wxEvent * >(argp1);
18951 {
18952 PyThreadState* __tstate = wxPyBeginAllowThreads();
18953 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
18954 wxPyEndAllowThreads(__tstate);
18955 if (PyErr_Occurred()) SWIG_fail;
18956 }
18957 {
18958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18959 }
18960 return resultobj;
18961 fail:
18962 return NULL;
18963 }
18964
18965
18966 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18967 PyObject *resultobj = 0;
18968 wxEvent *arg1 = (wxEvent *) 0 ;
18969 int result;
18970 void *argp1 = 0 ;
18971 int res1 = 0 ;
18972 PyObject *swig_obj[1] ;
18973
18974 if (!args) SWIG_fail;
18975 swig_obj[0] = args;
18976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18977 if (!SWIG_IsOK(res1)) {
18978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18979 }
18980 arg1 = reinterpret_cast< wxEvent * >(argp1);
18981 {
18982 PyThreadState* __tstate = wxPyBeginAllowThreads();
18983 result = (int)(arg1)->StopPropagation();
18984 wxPyEndAllowThreads(__tstate);
18985 if (PyErr_Occurred()) SWIG_fail;
18986 }
18987 resultobj = SWIG_From_int(static_cast< int >(result));
18988 return resultobj;
18989 fail:
18990 return NULL;
18991 }
18992
18993
18994 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18995 PyObject *resultobj = 0;
18996 wxEvent *arg1 = (wxEvent *) 0 ;
18997 int arg2 ;
18998 void *argp1 = 0 ;
18999 int res1 = 0 ;
19000 int val2 ;
19001 int ecode2 = 0 ;
19002 PyObject * obj0 = 0 ;
19003 PyObject * obj1 = 0 ;
19004 char * kwnames[] = {
19005 (char *) "self",(char *) "propagationLevel", NULL
19006 };
19007
19008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
19009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19010 if (!SWIG_IsOK(res1)) {
19011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
19012 }
19013 arg1 = reinterpret_cast< wxEvent * >(argp1);
19014 ecode2 = SWIG_AsVal_int(obj1, &val2);
19015 if (!SWIG_IsOK(ecode2)) {
19016 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
19017 }
19018 arg2 = static_cast< int >(val2);
19019 {
19020 PyThreadState* __tstate = wxPyBeginAllowThreads();
19021 (arg1)->ResumePropagation(arg2);
19022 wxPyEndAllowThreads(__tstate);
19023 if (PyErr_Occurred()) SWIG_fail;
19024 }
19025 resultobj = SWIG_Py_Void();
19026 return resultobj;
19027 fail:
19028 return NULL;
19029 }
19030
19031
19032 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19033 PyObject *resultobj = 0;
19034 wxEvent *arg1 = (wxEvent *) 0 ;
19035 wxEvent *result = 0 ;
19036 void *argp1 = 0 ;
19037 int res1 = 0 ;
19038 PyObject *swig_obj[1] ;
19039
19040 if (!args) SWIG_fail;
19041 swig_obj[0] = args;
19042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
19043 if (!SWIG_IsOK(res1)) {
19044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
19045 }
19046 arg1 = reinterpret_cast< wxEvent * >(argp1);
19047 {
19048 PyThreadState* __tstate = wxPyBeginAllowThreads();
19049 result = (wxEvent *)(arg1)->Clone();
19050 wxPyEndAllowThreads(__tstate);
19051 if (PyErr_Occurred()) SWIG_fail;
19052 }
19053 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19054 return resultobj;
19055 fail:
19056 return NULL;
19057 }
19058
19059
19060 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19061 PyObject *obj;
19062 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19063 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
19064 return SWIG_Py_Void();
19065 }
19066
19067 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19068 PyObject *resultobj = 0;
19069 wxEvent *arg1 = 0 ;
19070 wxPropagationDisabler *result = 0 ;
19071 void *argp1 = 0 ;
19072 int res1 = 0 ;
19073 PyObject * obj0 = 0 ;
19074 char * kwnames[] = {
19075 (char *) "event", NULL
19076 };
19077
19078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
19079 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
19080 if (!SWIG_IsOK(res1)) {
19081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
19082 }
19083 if (!argp1) {
19084 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
19085 }
19086 arg1 = reinterpret_cast< wxEvent * >(argp1);
19087 {
19088 PyThreadState* __tstate = wxPyBeginAllowThreads();
19089 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
19090 wxPyEndAllowThreads(__tstate);
19091 if (PyErr_Occurred()) SWIG_fail;
19092 }
19093 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
19094 return resultobj;
19095 fail:
19096 return NULL;
19097 }
19098
19099
19100 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19101 PyObject *resultobj = 0;
19102 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
19103 void *argp1 = 0 ;
19104 int res1 = 0 ;
19105 PyObject *swig_obj[1] ;
19106
19107 if (!args) SWIG_fail;
19108 swig_obj[0] = args;
19109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
19110 if (!SWIG_IsOK(res1)) {
19111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
19112 }
19113 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
19114 {
19115 PyThreadState* __tstate = wxPyBeginAllowThreads();
19116 delete arg1;
19117
19118 wxPyEndAllowThreads(__tstate);
19119 if (PyErr_Occurred()) SWIG_fail;
19120 }
19121 resultobj = SWIG_Py_Void();
19122 return resultobj;
19123 fail:
19124 return NULL;
19125 }
19126
19127
19128 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19129 PyObject *obj;
19130 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19131 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
19132 return SWIG_Py_Void();
19133 }
19134
19135 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19136 return SWIG_Python_InitShadowInstance(args);
19137 }
19138
19139 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19140 PyObject *resultobj = 0;
19141 wxEvent *arg1 = 0 ;
19142 wxPropagateOnce *result = 0 ;
19143 void *argp1 = 0 ;
19144 int res1 = 0 ;
19145 PyObject * obj0 = 0 ;
19146 char * kwnames[] = {
19147 (char *) "event", NULL
19148 };
19149
19150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
19151 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
19152 if (!SWIG_IsOK(res1)) {
19153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
19154 }
19155 if (!argp1) {
19156 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
19157 }
19158 arg1 = reinterpret_cast< wxEvent * >(argp1);
19159 {
19160 PyThreadState* __tstate = wxPyBeginAllowThreads();
19161 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
19162 wxPyEndAllowThreads(__tstate);
19163 if (PyErr_Occurred()) SWIG_fail;
19164 }
19165 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
19166 return resultobj;
19167 fail:
19168 return NULL;
19169 }
19170
19171
19172 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19173 PyObject *resultobj = 0;
19174 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
19175 void *argp1 = 0 ;
19176 int res1 = 0 ;
19177 PyObject *swig_obj[1] ;
19178
19179 if (!args) SWIG_fail;
19180 swig_obj[0] = args;
19181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
19182 if (!SWIG_IsOK(res1)) {
19183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
19184 }
19185 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
19186 {
19187 PyThreadState* __tstate = wxPyBeginAllowThreads();
19188 delete arg1;
19189
19190 wxPyEndAllowThreads(__tstate);
19191 if (PyErr_Occurred()) SWIG_fail;
19192 }
19193 resultobj = SWIG_Py_Void();
19194 return resultobj;
19195 fail:
19196 return NULL;
19197 }
19198
19199
19200 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19201 PyObject *obj;
19202 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19203 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
19204 return SWIG_Py_Void();
19205 }
19206
19207 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19208 return SWIG_Python_InitShadowInstance(args);
19209 }
19210
19211 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19212 PyObject *resultobj = 0;
19213 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19214 int arg2 = (int) 0 ;
19215 wxCommandEvent *result = 0 ;
19216 int val1 ;
19217 int ecode1 = 0 ;
19218 int val2 ;
19219 int ecode2 = 0 ;
19220 PyObject * obj0 = 0 ;
19221 PyObject * obj1 = 0 ;
19222 char * kwnames[] = {
19223 (char *) "commandType",(char *) "winid", NULL
19224 };
19225
19226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19227 if (obj0) {
19228 ecode1 = SWIG_AsVal_int(obj0, &val1);
19229 if (!SWIG_IsOK(ecode1)) {
19230 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19231 }
19232 arg1 = static_cast< wxEventType >(val1);
19233 }
19234 if (obj1) {
19235 ecode2 = SWIG_AsVal_int(obj1, &val2);
19236 if (!SWIG_IsOK(ecode2)) {
19237 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
19238 }
19239 arg2 = static_cast< int >(val2);
19240 }
19241 {
19242 PyThreadState* __tstate = wxPyBeginAllowThreads();
19243 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
19244 wxPyEndAllowThreads(__tstate);
19245 if (PyErr_Occurred()) SWIG_fail;
19246 }
19247 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
19248 return resultobj;
19249 fail:
19250 return NULL;
19251 }
19252
19253
19254 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19255 PyObject *resultobj = 0;
19256 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19257 int result;
19258 void *argp1 = 0 ;
19259 int res1 = 0 ;
19260 PyObject *swig_obj[1] ;
19261
19262 if (!args) SWIG_fail;
19263 swig_obj[0] = args;
19264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19265 if (!SWIG_IsOK(res1)) {
19266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19267 }
19268 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19269 {
19270 PyThreadState* __tstate = wxPyBeginAllowThreads();
19271 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
19272 wxPyEndAllowThreads(__tstate);
19273 if (PyErr_Occurred()) SWIG_fail;
19274 }
19275 resultobj = SWIG_From_int(static_cast< int >(result));
19276 return resultobj;
19277 fail:
19278 return NULL;
19279 }
19280
19281
19282 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19283 PyObject *resultobj = 0;
19284 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19285 wxString *arg2 = 0 ;
19286 void *argp1 = 0 ;
19287 int res1 = 0 ;
19288 bool temp2 = false ;
19289 PyObject * obj0 = 0 ;
19290 PyObject * obj1 = 0 ;
19291 char * kwnames[] = {
19292 (char *) "self",(char *) "s", NULL
19293 };
19294
19295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
19296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19297 if (!SWIG_IsOK(res1)) {
19298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19299 }
19300 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19301 {
19302 arg2 = wxString_in_helper(obj1);
19303 if (arg2 == NULL) SWIG_fail;
19304 temp2 = true;
19305 }
19306 {
19307 PyThreadState* __tstate = wxPyBeginAllowThreads();
19308 (arg1)->SetString((wxString const &)*arg2);
19309 wxPyEndAllowThreads(__tstate);
19310 if (PyErr_Occurred()) SWIG_fail;
19311 }
19312 resultobj = SWIG_Py_Void();
19313 {
19314 if (temp2)
19315 delete arg2;
19316 }
19317 return resultobj;
19318 fail:
19319 {
19320 if (temp2)
19321 delete arg2;
19322 }
19323 return NULL;
19324 }
19325
19326
19327 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19328 PyObject *resultobj = 0;
19329 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19330 wxString result;
19331 void *argp1 = 0 ;
19332 int res1 = 0 ;
19333 PyObject *swig_obj[1] ;
19334
19335 if (!args) SWIG_fail;
19336 swig_obj[0] = args;
19337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19338 if (!SWIG_IsOK(res1)) {
19339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19340 }
19341 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19342 {
19343 PyThreadState* __tstate = wxPyBeginAllowThreads();
19344 result = ((wxCommandEvent const *)arg1)->GetString();
19345 wxPyEndAllowThreads(__tstate);
19346 if (PyErr_Occurred()) SWIG_fail;
19347 }
19348 {
19349 #if wxUSE_UNICODE
19350 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19351 #else
19352 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19353 #endif
19354 }
19355 return resultobj;
19356 fail:
19357 return NULL;
19358 }
19359
19360
19361 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19362 PyObject *resultobj = 0;
19363 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19364 bool result;
19365 void *argp1 = 0 ;
19366 int res1 = 0 ;
19367 PyObject *swig_obj[1] ;
19368
19369 if (!args) SWIG_fail;
19370 swig_obj[0] = args;
19371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19372 if (!SWIG_IsOK(res1)) {
19373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19374 }
19375 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19376 {
19377 PyThreadState* __tstate = wxPyBeginAllowThreads();
19378 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
19379 wxPyEndAllowThreads(__tstate);
19380 if (PyErr_Occurred()) SWIG_fail;
19381 }
19382 {
19383 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19384 }
19385 return resultobj;
19386 fail:
19387 return NULL;
19388 }
19389
19390
19391 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19392 PyObject *resultobj = 0;
19393 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19394 bool result;
19395 void *argp1 = 0 ;
19396 int res1 = 0 ;
19397 PyObject *swig_obj[1] ;
19398
19399 if (!args) SWIG_fail;
19400 swig_obj[0] = args;
19401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19402 if (!SWIG_IsOK(res1)) {
19403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19404 }
19405 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19406 {
19407 PyThreadState* __tstate = wxPyBeginAllowThreads();
19408 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
19409 wxPyEndAllowThreads(__tstate);
19410 if (PyErr_Occurred()) SWIG_fail;
19411 }
19412 {
19413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19414 }
19415 return resultobj;
19416 fail:
19417 return NULL;
19418 }
19419
19420
19421 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19422 PyObject *resultobj = 0;
19423 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19424 long arg2 ;
19425 void *argp1 = 0 ;
19426 int res1 = 0 ;
19427 long val2 ;
19428 int ecode2 = 0 ;
19429 PyObject * obj0 = 0 ;
19430 PyObject * obj1 = 0 ;
19431 char * kwnames[] = {
19432 (char *) "self",(char *) "extraLong", NULL
19433 };
19434
19435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
19436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19437 if (!SWIG_IsOK(res1)) {
19438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19439 }
19440 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19441 ecode2 = SWIG_AsVal_long(obj1, &val2);
19442 if (!SWIG_IsOK(ecode2)) {
19443 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
19444 }
19445 arg2 = static_cast< long >(val2);
19446 {
19447 PyThreadState* __tstate = wxPyBeginAllowThreads();
19448 (arg1)->SetExtraLong(arg2);
19449 wxPyEndAllowThreads(__tstate);
19450 if (PyErr_Occurred()) SWIG_fail;
19451 }
19452 resultobj = SWIG_Py_Void();
19453 return resultobj;
19454 fail:
19455 return NULL;
19456 }
19457
19458
19459 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19460 PyObject *resultobj = 0;
19461 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19462 long result;
19463 void *argp1 = 0 ;
19464 int res1 = 0 ;
19465 PyObject *swig_obj[1] ;
19466
19467 if (!args) SWIG_fail;
19468 swig_obj[0] = args;
19469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19470 if (!SWIG_IsOK(res1)) {
19471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19472 }
19473 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19474 {
19475 PyThreadState* __tstate = wxPyBeginAllowThreads();
19476 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19477 wxPyEndAllowThreads(__tstate);
19478 if (PyErr_Occurred()) SWIG_fail;
19479 }
19480 resultobj = SWIG_From_long(static_cast< long >(result));
19481 return resultobj;
19482 fail:
19483 return NULL;
19484 }
19485
19486
19487 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19488 PyObject *resultobj = 0;
19489 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19490 int arg2 ;
19491 void *argp1 = 0 ;
19492 int res1 = 0 ;
19493 int val2 ;
19494 int ecode2 = 0 ;
19495 PyObject * obj0 = 0 ;
19496 PyObject * obj1 = 0 ;
19497 char * kwnames[] = {
19498 (char *) "self",(char *) "i", NULL
19499 };
19500
19501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19503 if (!SWIG_IsOK(res1)) {
19504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19505 }
19506 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19507 ecode2 = SWIG_AsVal_int(obj1, &val2);
19508 if (!SWIG_IsOK(ecode2)) {
19509 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19510 }
19511 arg2 = static_cast< int >(val2);
19512 {
19513 PyThreadState* __tstate = wxPyBeginAllowThreads();
19514 (arg1)->SetInt(arg2);
19515 wxPyEndAllowThreads(__tstate);
19516 if (PyErr_Occurred()) SWIG_fail;
19517 }
19518 resultobj = SWIG_Py_Void();
19519 return resultobj;
19520 fail:
19521 return NULL;
19522 }
19523
19524
19525 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19526 PyObject *resultobj = 0;
19527 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19528 int result;
19529 void *argp1 = 0 ;
19530 int res1 = 0 ;
19531 PyObject *swig_obj[1] ;
19532
19533 if (!args) SWIG_fail;
19534 swig_obj[0] = args;
19535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19536 if (!SWIG_IsOK(res1)) {
19537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19538 }
19539 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19540 {
19541 PyThreadState* __tstate = wxPyBeginAllowThreads();
19542 result = (int)((wxCommandEvent const *)arg1)->GetInt();
19543 wxPyEndAllowThreads(__tstate);
19544 if (PyErr_Occurred()) SWIG_fail;
19545 }
19546 resultobj = SWIG_From_int(static_cast< int >(result));
19547 return resultobj;
19548 fail:
19549 return NULL;
19550 }
19551
19552
19553 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19554 PyObject *resultobj = 0;
19555 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19556 PyObject *result = 0 ;
19557 void *argp1 = 0 ;
19558 int res1 = 0 ;
19559 PyObject *swig_obj[1] ;
19560
19561 if (!args) SWIG_fail;
19562 swig_obj[0] = args;
19563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19564 if (!SWIG_IsOK(res1)) {
19565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19566 }
19567 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19568 {
19569 PyThreadState* __tstate = wxPyBeginAllowThreads();
19570 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19571 wxPyEndAllowThreads(__tstate);
19572 if (PyErr_Occurred()) SWIG_fail;
19573 }
19574 resultobj = result;
19575 return resultobj;
19576 fail:
19577 return NULL;
19578 }
19579
19580
19581 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19582 PyObject *resultobj = 0;
19583 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19584 PyObject *arg2 = (PyObject *) 0 ;
19585 void *argp1 = 0 ;
19586 int res1 = 0 ;
19587 PyObject * obj0 = 0 ;
19588 PyObject * obj1 = 0 ;
19589 char * kwnames[] = {
19590 (char *) "self",(char *) "clientData", NULL
19591 };
19592
19593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19595 if (!SWIG_IsOK(res1)) {
19596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19597 }
19598 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19599 arg2 = obj1;
19600 {
19601 PyThreadState* __tstate = wxPyBeginAllowThreads();
19602 wxCommandEvent_SetClientData(arg1,arg2);
19603 wxPyEndAllowThreads(__tstate);
19604 if (PyErr_Occurred()) SWIG_fail;
19605 }
19606 resultobj = SWIG_Py_Void();
19607 return resultobj;
19608 fail:
19609 return NULL;
19610 }
19611
19612
19613 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19614 PyObject *resultobj = 0;
19615 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19616 wxEvent *result = 0 ;
19617 void *argp1 = 0 ;
19618 int res1 = 0 ;
19619 PyObject *swig_obj[1] ;
19620
19621 if (!args) SWIG_fail;
19622 swig_obj[0] = args;
19623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19624 if (!SWIG_IsOK(res1)) {
19625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19626 }
19627 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19628 {
19629 PyThreadState* __tstate = wxPyBeginAllowThreads();
19630 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19631 wxPyEndAllowThreads(__tstate);
19632 if (PyErr_Occurred()) SWIG_fail;
19633 }
19634 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19635 return resultobj;
19636 fail:
19637 return NULL;
19638 }
19639
19640
19641 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19642 PyObject *obj;
19643 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19644 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19645 return SWIG_Py_Void();
19646 }
19647
19648 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19649 return SWIG_Python_InitShadowInstance(args);
19650 }
19651
19652 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19653 PyObject *resultobj = 0;
19654 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19655 int arg2 = (int) 0 ;
19656 wxNotifyEvent *result = 0 ;
19657 int val1 ;
19658 int ecode1 = 0 ;
19659 int val2 ;
19660 int ecode2 = 0 ;
19661 PyObject * obj0 = 0 ;
19662 PyObject * obj1 = 0 ;
19663 char * kwnames[] = {
19664 (char *) "commandType",(char *) "winid", NULL
19665 };
19666
19667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19668 if (obj0) {
19669 ecode1 = SWIG_AsVal_int(obj0, &val1);
19670 if (!SWIG_IsOK(ecode1)) {
19671 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19672 }
19673 arg1 = static_cast< wxEventType >(val1);
19674 }
19675 if (obj1) {
19676 ecode2 = SWIG_AsVal_int(obj1, &val2);
19677 if (!SWIG_IsOK(ecode2)) {
19678 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19679 }
19680 arg2 = static_cast< int >(val2);
19681 }
19682 {
19683 PyThreadState* __tstate = wxPyBeginAllowThreads();
19684 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19685 wxPyEndAllowThreads(__tstate);
19686 if (PyErr_Occurred()) SWIG_fail;
19687 }
19688 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
19689 return resultobj;
19690 fail:
19691 return NULL;
19692 }
19693
19694
19695 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19696 PyObject *resultobj = 0;
19697 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19698 void *argp1 = 0 ;
19699 int res1 = 0 ;
19700 PyObject *swig_obj[1] ;
19701
19702 if (!args) SWIG_fail;
19703 swig_obj[0] = args;
19704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19705 if (!SWIG_IsOK(res1)) {
19706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19707 }
19708 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19709 {
19710 PyThreadState* __tstate = wxPyBeginAllowThreads();
19711 (arg1)->Veto();
19712 wxPyEndAllowThreads(__tstate);
19713 if (PyErr_Occurred()) SWIG_fail;
19714 }
19715 resultobj = SWIG_Py_Void();
19716 return resultobj;
19717 fail:
19718 return NULL;
19719 }
19720
19721
19722 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19723 PyObject *resultobj = 0;
19724 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19725 void *argp1 = 0 ;
19726 int res1 = 0 ;
19727 PyObject *swig_obj[1] ;
19728
19729 if (!args) SWIG_fail;
19730 swig_obj[0] = args;
19731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19732 if (!SWIG_IsOK(res1)) {
19733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19734 }
19735 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19736 {
19737 PyThreadState* __tstate = wxPyBeginAllowThreads();
19738 (arg1)->Allow();
19739 wxPyEndAllowThreads(__tstate);
19740 if (PyErr_Occurred()) SWIG_fail;
19741 }
19742 resultobj = SWIG_Py_Void();
19743 return resultobj;
19744 fail:
19745 return NULL;
19746 }
19747
19748
19749 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19750 PyObject *resultobj = 0;
19751 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19752 bool result;
19753 void *argp1 = 0 ;
19754 int res1 = 0 ;
19755 PyObject *swig_obj[1] ;
19756
19757 if (!args) SWIG_fail;
19758 swig_obj[0] = args;
19759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19760 if (!SWIG_IsOK(res1)) {
19761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19762 }
19763 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19764 {
19765 PyThreadState* __tstate = wxPyBeginAllowThreads();
19766 result = (bool)(arg1)->IsAllowed();
19767 wxPyEndAllowThreads(__tstate);
19768 if (PyErr_Occurred()) SWIG_fail;
19769 }
19770 {
19771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19772 }
19773 return resultobj;
19774 fail:
19775 return NULL;
19776 }
19777
19778
19779 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19780 PyObject *obj;
19781 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19782 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
19783 return SWIG_Py_Void();
19784 }
19785
19786 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19787 return SWIG_Python_InitShadowInstance(args);
19788 }
19789
19790 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19791 PyObject *resultobj = 0;
19792 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19793 int arg2 = (int) 0 ;
19794 int arg3 = (int) 0 ;
19795 int arg4 = (int) 0 ;
19796 wxScrollEvent *result = 0 ;
19797 int val1 ;
19798 int ecode1 = 0 ;
19799 int val2 ;
19800 int ecode2 = 0 ;
19801 int val3 ;
19802 int ecode3 = 0 ;
19803 int val4 ;
19804 int ecode4 = 0 ;
19805 PyObject * obj0 = 0 ;
19806 PyObject * obj1 = 0 ;
19807 PyObject * obj2 = 0 ;
19808 PyObject * obj3 = 0 ;
19809 char * kwnames[] = {
19810 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
19811 };
19812
19813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19814 if (obj0) {
19815 ecode1 = SWIG_AsVal_int(obj0, &val1);
19816 if (!SWIG_IsOK(ecode1)) {
19817 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19818 }
19819 arg1 = static_cast< wxEventType >(val1);
19820 }
19821 if (obj1) {
19822 ecode2 = SWIG_AsVal_int(obj1, &val2);
19823 if (!SWIG_IsOK(ecode2)) {
19824 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
19825 }
19826 arg2 = static_cast< int >(val2);
19827 }
19828 if (obj2) {
19829 ecode3 = SWIG_AsVal_int(obj2, &val3);
19830 if (!SWIG_IsOK(ecode3)) {
19831 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
19832 }
19833 arg3 = static_cast< int >(val3);
19834 }
19835 if (obj3) {
19836 ecode4 = SWIG_AsVal_int(obj3, &val4);
19837 if (!SWIG_IsOK(ecode4)) {
19838 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
19839 }
19840 arg4 = static_cast< int >(val4);
19841 }
19842 {
19843 PyThreadState* __tstate = wxPyBeginAllowThreads();
19844 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
19845 wxPyEndAllowThreads(__tstate);
19846 if (PyErr_Occurred()) SWIG_fail;
19847 }
19848 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
19849 return resultobj;
19850 fail:
19851 return NULL;
19852 }
19853
19854
19855 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19856 PyObject *resultobj = 0;
19857 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19858 int result;
19859 void *argp1 = 0 ;
19860 int res1 = 0 ;
19861 PyObject *swig_obj[1] ;
19862
19863 if (!args) SWIG_fail;
19864 swig_obj[0] = args;
19865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19866 if (!SWIG_IsOK(res1)) {
19867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19868 }
19869 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19870 {
19871 PyThreadState* __tstate = wxPyBeginAllowThreads();
19872 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
19873 wxPyEndAllowThreads(__tstate);
19874 if (PyErr_Occurred()) SWIG_fail;
19875 }
19876 resultobj = SWIG_From_int(static_cast< int >(result));
19877 return resultobj;
19878 fail:
19879 return NULL;
19880 }
19881
19882
19883 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19884 PyObject *resultobj = 0;
19885 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19886 int result;
19887 void *argp1 = 0 ;
19888 int res1 = 0 ;
19889 PyObject *swig_obj[1] ;
19890
19891 if (!args) SWIG_fail;
19892 swig_obj[0] = args;
19893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19894 if (!SWIG_IsOK(res1)) {
19895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19896 }
19897 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19898 {
19899 PyThreadState* __tstate = wxPyBeginAllowThreads();
19900 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
19901 wxPyEndAllowThreads(__tstate);
19902 if (PyErr_Occurred()) SWIG_fail;
19903 }
19904 resultobj = SWIG_From_int(static_cast< int >(result));
19905 return resultobj;
19906 fail:
19907 return NULL;
19908 }
19909
19910
19911 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19912 PyObject *resultobj = 0;
19913 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19914 int arg2 ;
19915 void *argp1 = 0 ;
19916 int res1 = 0 ;
19917 int val2 ;
19918 int ecode2 = 0 ;
19919 PyObject * obj0 = 0 ;
19920 PyObject * obj1 = 0 ;
19921 char * kwnames[] = {
19922 (char *) "self",(char *) "orient", NULL
19923 };
19924
19925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19927 if (!SWIG_IsOK(res1)) {
19928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19929 }
19930 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19931 ecode2 = SWIG_AsVal_int(obj1, &val2);
19932 if (!SWIG_IsOK(ecode2)) {
19933 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19934 }
19935 arg2 = static_cast< int >(val2);
19936 {
19937 PyThreadState* __tstate = wxPyBeginAllowThreads();
19938 (arg1)->SetOrientation(arg2);
19939 wxPyEndAllowThreads(__tstate);
19940 if (PyErr_Occurred()) SWIG_fail;
19941 }
19942 resultobj = SWIG_Py_Void();
19943 return resultobj;
19944 fail:
19945 return NULL;
19946 }
19947
19948
19949 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19950 PyObject *resultobj = 0;
19951 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19952 int arg2 ;
19953 void *argp1 = 0 ;
19954 int res1 = 0 ;
19955 int val2 ;
19956 int ecode2 = 0 ;
19957 PyObject * obj0 = 0 ;
19958 PyObject * obj1 = 0 ;
19959 char * kwnames[] = {
19960 (char *) "self",(char *) "pos", NULL
19961 };
19962
19963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19965 if (!SWIG_IsOK(res1)) {
19966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19967 }
19968 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19969 ecode2 = SWIG_AsVal_int(obj1, &val2);
19970 if (!SWIG_IsOK(ecode2)) {
19971 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19972 }
19973 arg2 = static_cast< int >(val2);
19974 {
19975 PyThreadState* __tstate = wxPyBeginAllowThreads();
19976 (arg1)->SetPosition(arg2);
19977 wxPyEndAllowThreads(__tstate);
19978 if (PyErr_Occurred()) SWIG_fail;
19979 }
19980 resultobj = SWIG_Py_Void();
19981 return resultobj;
19982 fail:
19983 return NULL;
19984 }
19985
19986
19987 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19988 PyObject *obj;
19989 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19990 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
19991 return SWIG_Py_Void();
19992 }
19993
19994 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19995 return SWIG_Python_InitShadowInstance(args);
19996 }
19997
19998 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19999 PyObject *resultobj = 0;
20000 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20001 int arg2 = (int) 0 ;
20002 int arg3 = (int) 0 ;
20003 wxScrollWinEvent *result = 0 ;
20004 int val1 ;
20005 int ecode1 = 0 ;
20006 int val2 ;
20007 int ecode2 = 0 ;
20008 int val3 ;
20009 int ecode3 = 0 ;
20010 PyObject * obj0 = 0 ;
20011 PyObject * obj1 = 0 ;
20012 PyObject * obj2 = 0 ;
20013 char * kwnames[] = {
20014 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
20015 };
20016
20017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
20018 if (obj0) {
20019 ecode1 = SWIG_AsVal_int(obj0, &val1);
20020 if (!SWIG_IsOK(ecode1)) {
20021 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20022 }
20023 arg1 = static_cast< wxEventType >(val1);
20024 }
20025 if (obj1) {
20026 ecode2 = SWIG_AsVal_int(obj1, &val2);
20027 if (!SWIG_IsOK(ecode2)) {
20028 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
20029 }
20030 arg2 = static_cast< int >(val2);
20031 }
20032 if (obj2) {
20033 ecode3 = SWIG_AsVal_int(obj2, &val3);
20034 if (!SWIG_IsOK(ecode3)) {
20035 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
20036 }
20037 arg3 = static_cast< int >(val3);
20038 }
20039 {
20040 PyThreadState* __tstate = wxPyBeginAllowThreads();
20041 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
20042 wxPyEndAllowThreads(__tstate);
20043 if (PyErr_Occurred()) SWIG_fail;
20044 }
20045 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
20046 return resultobj;
20047 fail:
20048 return NULL;
20049 }
20050
20051
20052 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20053 PyObject *resultobj = 0;
20054 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20055 int result;
20056 void *argp1 = 0 ;
20057 int res1 = 0 ;
20058 PyObject *swig_obj[1] ;
20059
20060 if (!args) SWIG_fail;
20061 swig_obj[0] = args;
20062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20063 if (!SWIG_IsOK(res1)) {
20064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
20065 }
20066 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20067 {
20068 PyThreadState* __tstate = wxPyBeginAllowThreads();
20069 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
20070 wxPyEndAllowThreads(__tstate);
20071 if (PyErr_Occurred()) SWIG_fail;
20072 }
20073 resultobj = SWIG_From_int(static_cast< int >(result));
20074 return resultobj;
20075 fail:
20076 return NULL;
20077 }
20078
20079
20080 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20081 PyObject *resultobj = 0;
20082 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20083 int result;
20084 void *argp1 = 0 ;
20085 int res1 = 0 ;
20086 PyObject *swig_obj[1] ;
20087
20088 if (!args) SWIG_fail;
20089 swig_obj[0] = args;
20090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20091 if (!SWIG_IsOK(res1)) {
20092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
20093 }
20094 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20095 {
20096 PyThreadState* __tstate = wxPyBeginAllowThreads();
20097 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
20098 wxPyEndAllowThreads(__tstate);
20099 if (PyErr_Occurred()) SWIG_fail;
20100 }
20101 resultobj = SWIG_From_int(static_cast< int >(result));
20102 return resultobj;
20103 fail:
20104 return NULL;
20105 }
20106
20107
20108 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20109 PyObject *resultobj = 0;
20110 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20111 int arg2 ;
20112 void *argp1 = 0 ;
20113 int res1 = 0 ;
20114 int val2 ;
20115 int ecode2 = 0 ;
20116 PyObject * obj0 = 0 ;
20117 PyObject * obj1 = 0 ;
20118 char * kwnames[] = {
20119 (char *) "self",(char *) "orient", NULL
20120 };
20121
20122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
20123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20124 if (!SWIG_IsOK(res1)) {
20125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
20126 }
20127 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20128 ecode2 = SWIG_AsVal_int(obj1, &val2);
20129 if (!SWIG_IsOK(ecode2)) {
20130 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
20131 }
20132 arg2 = static_cast< int >(val2);
20133 {
20134 PyThreadState* __tstate = wxPyBeginAllowThreads();
20135 (arg1)->SetOrientation(arg2);
20136 wxPyEndAllowThreads(__tstate);
20137 if (PyErr_Occurred()) SWIG_fail;
20138 }
20139 resultobj = SWIG_Py_Void();
20140 return resultobj;
20141 fail:
20142 return NULL;
20143 }
20144
20145
20146 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20147 PyObject *resultobj = 0;
20148 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20149 int arg2 ;
20150 void *argp1 = 0 ;
20151 int res1 = 0 ;
20152 int val2 ;
20153 int ecode2 = 0 ;
20154 PyObject * obj0 = 0 ;
20155 PyObject * obj1 = 0 ;
20156 char * kwnames[] = {
20157 (char *) "self",(char *) "pos", NULL
20158 };
20159
20160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20162 if (!SWIG_IsOK(res1)) {
20163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
20164 }
20165 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20166 ecode2 = SWIG_AsVal_int(obj1, &val2);
20167 if (!SWIG_IsOK(ecode2)) {
20168 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
20169 }
20170 arg2 = static_cast< int >(val2);
20171 {
20172 PyThreadState* __tstate = wxPyBeginAllowThreads();
20173 (arg1)->SetPosition(arg2);
20174 wxPyEndAllowThreads(__tstate);
20175 if (PyErr_Occurred()) SWIG_fail;
20176 }
20177 resultobj = SWIG_Py_Void();
20178 return resultobj;
20179 fail:
20180 return NULL;
20181 }
20182
20183
20184 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20185 PyObject *obj;
20186 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20187 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
20188 return SWIG_Py_Void();
20189 }
20190
20191 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20192 return SWIG_Python_InitShadowInstance(args);
20193 }
20194
20195 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20196 PyObject *resultobj = 0;
20197 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20198 wxMouseEvent *result = 0 ;
20199 int val1 ;
20200 int ecode1 = 0 ;
20201 PyObject * obj0 = 0 ;
20202 char * kwnames[] = {
20203 (char *) "mouseType", NULL
20204 };
20205
20206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
20207 if (obj0) {
20208 ecode1 = SWIG_AsVal_int(obj0, &val1);
20209 if (!SWIG_IsOK(ecode1)) {
20210 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20211 }
20212 arg1 = static_cast< wxEventType >(val1);
20213 }
20214 {
20215 PyThreadState* __tstate = wxPyBeginAllowThreads();
20216 result = (wxMouseEvent *)new wxMouseEvent(arg1);
20217 wxPyEndAllowThreads(__tstate);
20218 if (PyErr_Occurred()) SWIG_fail;
20219 }
20220 {
20221 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
20222 }
20223 return resultobj;
20224 fail:
20225 return NULL;
20226 }
20227
20228
20229 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20230 PyObject *resultobj = 0;
20231 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20232 bool result;
20233 void *argp1 = 0 ;
20234 int res1 = 0 ;
20235 PyObject *swig_obj[1] ;
20236
20237 if (!args) SWIG_fail;
20238 swig_obj[0] = args;
20239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20240 if (!SWIG_IsOK(res1)) {
20241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20242 }
20243 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20244 {
20245 PyThreadState* __tstate = wxPyBeginAllowThreads();
20246 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
20247 wxPyEndAllowThreads(__tstate);
20248 if (PyErr_Occurred()) SWIG_fail;
20249 }
20250 {
20251 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20252 }
20253 return resultobj;
20254 fail:
20255 return NULL;
20256 }
20257
20258
20259 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20260 PyObject *resultobj = 0;
20261 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20262 int arg2 = (int) wxMOUSE_BTN_ANY ;
20263 bool result;
20264 void *argp1 = 0 ;
20265 int res1 = 0 ;
20266 int val2 ;
20267 int ecode2 = 0 ;
20268 PyObject * obj0 = 0 ;
20269 PyObject * obj1 = 0 ;
20270 char * kwnames[] = {
20271 (char *) "self",(char *) "but", NULL
20272 };
20273
20274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
20275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20276 if (!SWIG_IsOK(res1)) {
20277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20278 }
20279 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20280 if (obj1) {
20281 ecode2 = SWIG_AsVal_int(obj1, &val2);
20282 if (!SWIG_IsOK(ecode2)) {
20283 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
20284 }
20285 arg2 = static_cast< int >(val2);
20286 }
20287 {
20288 PyThreadState* __tstate = wxPyBeginAllowThreads();
20289 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
20290 wxPyEndAllowThreads(__tstate);
20291 if (PyErr_Occurred()) SWIG_fail;
20292 }
20293 {
20294 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20295 }
20296 return resultobj;
20297 fail:
20298 return NULL;
20299 }
20300
20301
20302 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20303 PyObject *resultobj = 0;
20304 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20305 int arg2 = (int) wxMOUSE_BTN_ANY ;
20306 bool result;
20307 void *argp1 = 0 ;
20308 int res1 = 0 ;
20309 int val2 ;
20310 int ecode2 = 0 ;
20311 PyObject * obj0 = 0 ;
20312 PyObject * obj1 = 0 ;
20313 char * kwnames[] = {
20314 (char *) "self",(char *) "but", NULL
20315 };
20316
20317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
20318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20319 if (!SWIG_IsOK(res1)) {
20320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20321 }
20322 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20323 if (obj1) {
20324 ecode2 = SWIG_AsVal_int(obj1, &val2);
20325 if (!SWIG_IsOK(ecode2)) {
20326 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
20327 }
20328 arg2 = static_cast< int >(val2);
20329 }
20330 {
20331 PyThreadState* __tstate = wxPyBeginAllowThreads();
20332 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
20333 wxPyEndAllowThreads(__tstate);
20334 if (PyErr_Occurred()) SWIG_fail;
20335 }
20336 {
20337 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20338 }
20339 return resultobj;
20340 fail:
20341 return NULL;
20342 }
20343
20344
20345 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20346 PyObject *resultobj = 0;
20347 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20348 int arg2 = (int) wxMOUSE_BTN_ANY ;
20349 bool result;
20350 void *argp1 = 0 ;
20351 int res1 = 0 ;
20352 int val2 ;
20353 int ecode2 = 0 ;
20354 PyObject * obj0 = 0 ;
20355 PyObject * obj1 = 0 ;
20356 char * kwnames[] = {
20357 (char *) "self",(char *) "but", NULL
20358 };
20359
20360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
20361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20362 if (!SWIG_IsOK(res1)) {
20363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20364 }
20365 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20366 if (obj1) {
20367 ecode2 = SWIG_AsVal_int(obj1, &val2);
20368 if (!SWIG_IsOK(ecode2)) {
20369 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
20370 }
20371 arg2 = static_cast< int >(val2);
20372 }
20373 {
20374 PyThreadState* __tstate = wxPyBeginAllowThreads();
20375 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
20376 wxPyEndAllowThreads(__tstate);
20377 if (PyErr_Occurred()) SWIG_fail;
20378 }
20379 {
20380 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20381 }
20382 return resultobj;
20383 fail:
20384 return NULL;
20385 }
20386
20387
20388 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20389 PyObject *resultobj = 0;
20390 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20391 int arg2 ;
20392 bool result;
20393 void *argp1 = 0 ;
20394 int res1 = 0 ;
20395 int val2 ;
20396 int ecode2 = 0 ;
20397 PyObject * obj0 = 0 ;
20398 PyObject * obj1 = 0 ;
20399 char * kwnames[] = {
20400 (char *) "self",(char *) "button", NULL
20401 };
20402
20403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
20404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20405 if (!SWIG_IsOK(res1)) {
20406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20407 }
20408 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20409 ecode2 = SWIG_AsVal_int(obj1, &val2);
20410 if (!SWIG_IsOK(ecode2)) {
20411 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
20412 }
20413 arg2 = static_cast< int >(val2);
20414 {
20415 PyThreadState* __tstate = wxPyBeginAllowThreads();
20416 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
20417 wxPyEndAllowThreads(__tstate);
20418 if (PyErr_Occurred()) SWIG_fail;
20419 }
20420 {
20421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20422 }
20423 return resultobj;
20424 fail:
20425 return NULL;
20426 }
20427
20428
20429 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20430 PyObject *resultobj = 0;
20431 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20432 int arg2 ;
20433 bool result;
20434 void *argp1 = 0 ;
20435 int res1 = 0 ;
20436 int val2 ;
20437 int ecode2 = 0 ;
20438 PyObject * obj0 = 0 ;
20439 PyObject * obj1 = 0 ;
20440 char * kwnames[] = {
20441 (char *) "self",(char *) "but", NULL
20442 };
20443
20444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
20445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20446 if (!SWIG_IsOK(res1)) {
20447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20448 }
20449 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20450 ecode2 = SWIG_AsVal_int(obj1, &val2);
20451 if (!SWIG_IsOK(ecode2)) {
20452 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
20453 }
20454 arg2 = static_cast< int >(val2);
20455 {
20456 PyThreadState* __tstate = wxPyBeginAllowThreads();
20457 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20458 wxPyEndAllowThreads(__tstate);
20459 if (PyErr_Occurred()) SWIG_fail;
20460 }
20461 {
20462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20463 }
20464 return resultobj;
20465 fail:
20466 return NULL;
20467 }
20468
20469
20470 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20471 PyObject *resultobj = 0;
20472 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20473 int result;
20474 void *argp1 = 0 ;
20475 int res1 = 0 ;
20476 PyObject *swig_obj[1] ;
20477
20478 if (!args) SWIG_fail;
20479 swig_obj[0] = args;
20480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20481 if (!SWIG_IsOK(res1)) {
20482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20483 }
20484 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20485 {
20486 PyThreadState* __tstate = wxPyBeginAllowThreads();
20487 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20488 wxPyEndAllowThreads(__tstate);
20489 if (PyErr_Occurred()) SWIG_fail;
20490 }
20491 resultobj = SWIG_From_int(static_cast< int >(result));
20492 return resultobj;
20493 fail:
20494 return NULL;
20495 }
20496
20497
20498 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20499 PyObject *resultobj = 0;
20500 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20501 bool result;
20502 void *argp1 = 0 ;
20503 int res1 = 0 ;
20504 PyObject *swig_obj[1] ;
20505
20506 if (!args) SWIG_fail;
20507 swig_obj[0] = args;
20508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20509 if (!SWIG_IsOK(res1)) {
20510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20511 }
20512 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20513 {
20514 PyThreadState* __tstate = wxPyBeginAllowThreads();
20515 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20516 wxPyEndAllowThreads(__tstate);
20517 if (PyErr_Occurred()) SWIG_fail;
20518 }
20519 {
20520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20521 }
20522 return resultobj;
20523 fail:
20524 return NULL;
20525 }
20526
20527
20528 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20529 PyObject *resultobj = 0;
20530 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20531 bool result;
20532 void *argp1 = 0 ;
20533 int res1 = 0 ;
20534 PyObject *swig_obj[1] ;
20535
20536 if (!args) SWIG_fail;
20537 swig_obj[0] = args;
20538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20539 if (!SWIG_IsOK(res1)) {
20540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20541 }
20542 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20543 {
20544 PyThreadState* __tstate = wxPyBeginAllowThreads();
20545 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20546 wxPyEndAllowThreads(__tstate);
20547 if (PyErr_Occurred()) SWIG_fail;
20548 }
20549 {
20550 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20551 }
20552 return resultobj;
20553 fail:
20554 return NULL;
20555 }
20556
20557
20558 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20559 PyObject *resultobj = 0;
20560 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20561 bool result;
20562 void *argp1 = 0 ;
20563 int res1 = 0 ;
20564 PyObject *swig_obj[1] ;
20565
20566 if (!args) SWIG_fail;
20567 swig_obj[0] = args;
20568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20569 if (!SWIG_IsOK(res1)) {
20570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20571 }
20572 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20573 {
20574 PyThreadState* __tstate = wxPyBeginAllowThreads();
20575 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20576 wxPyEndAllowThreads(__tstate);
20577 if (PyErr_Occurred()) SWIG_fail;
20578 }
20579 {
20580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20581 }
20582 return resultobj;
20583 fail:
20584 return NULL;
20585 }
20586
20587
20588 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20589 PyObject *resultobj = 0;
20590 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20591 bool result;
20592 void *argp1 = 0 ;
20593 int res1 = 0 ;
20594 PyObject *swig_obj[1] ;
20595
20596 if (!args) SWIG_fail;
20597 swig_obj[0] = args;
20598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20599 if (!SWIG_IsOK(res1)) {
20600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20601 }
20602 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20603 {
20604 PyThreadState* __tstate = wxPyBeginAllowThreads();
20605 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20606 wxPyEndAllowThreads(__tstate);
20607 if (PyErr_Occurred()) SWIG_fail;
20608 }
20609 {
20610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20611 }
20612 return resultobj;
20613 fail:
20614 return NULL;
20615 }
20616
20617
20618 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20619 PyObject *resultobj = 0;
20620 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20621 bool result;
20622 void *argp1 = 0 ;
20623 int res1 = 0 ;
20624 PyObject *swig_obj[1] ;
20625
20626 if (!args) SWIG_fail;
20627 swig_obj[0] = args;
20628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20629 if (!SWIG_IsOK(res1)) {
20630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20631 }
20632 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20633 {
20634 PyThreadState* __tstate = wxPyBeginAllowThreads();
20635 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20636 wxPyEndAllowThreads(__tstate);
20637 if (PyErr_Occurred()) SWIG_fail;
20638 }
20639 {
20640 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20641 }
20642 return resultobj;
20643 fail:
20644 return NULL;
20645 }
20646
20647
20648 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20649 PyObject *resultobj = 0;
20650 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20651 bool result;
20652 void *argp1 = 0 ;
20653 int res1 = 0 ;
20654 PyObject *swig_obj[1] ;
20655
20656 if (!args) SWIG_fail;
20657 swig_obj[0] = args;
20658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20659 if (!SWIG_IsOK(res1)) {
20660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20661 }
20662 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20663 {
20664 PyThreadState* __tstate = wxPyBeginAllowThreads();
20665 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20666 wxPyEndAllowThreads(__tstate);
20667 if (PyErr_Occurred()) SWIG_fail;
20668 }
20669 {
20670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20671 }
20672 return resultobj;
20673 fail:
20674 return NULL;
20675 }
20676
20677
20678 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20679 PyObject *resultobj = 0;
20680 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20681 bool result;
20682 void *argp1 = 0 ;
20683 int res1 = 0 ;
20684 PyObject *swig_obj[1] ;
20685
20686 if (!args) SWIG_fail;
20687 swig_obj[0] = args;
20688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20689 if (!SWIG_IsOK(res1)) {
20690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20691 }
20692 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20693 {
20694 PyThreadState* __tstate = wxPyBeginAllowThreads();
20695 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
20696 wxPyEndAllowThreads(__tstate);
20697 if (PyErr_Occurred()) SWIG_fail;
20698 }
20699 {
20700 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20701 }
20702 return resultobj;
20703 fail:
20704 return NULL;
20705 }
20706
20707
20708 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20709 PyObject *resultobj = 0;
20710 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20711 bool result;
20712 void *argp1 = 0 ;
20713 int res1 = 0 ;
20714 PyObject *swig_obj[1] ;
20715
20716 if (!args) SWIG_fail;
20717 swig_obj[0] = args;
20718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20719 if (!SWIG_IsOK(res1)) {
20720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20721 }
20722 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20723 {
20724 PyThreadState* __tstate = wxPyBeginAllowThreads();
20725 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
20726 wxPyEndAllowThreads(__tstate);
20727 if (PyErr_Occurred()) SWIG_fail;
20728 }
20729 {
20730 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20731 }
20732 return resultobj;
20733 fail:
20734 return NULL;
20735 }
20736
20737
20738 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20739 PyObject *resultobj = 0;
20740 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20741 bool result;
20742 void *argp1 = 0 ;
20743 int res1 = 0 ;
20744 PyObject *swig_obj[1] ;
20745
20746 if (!args) SWIG_fail;
20747 swig_obj[0] = args;
20748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20749 if (!SWIG_IsOK(res1)) {
20750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20751 }
20752 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20753 {
20754 PyThreadState* __tstate = wxPyBeginAllowThreads();
20755 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
20756 wxPyEndAllowThreads(__tstate);
20757 if (PyErr_Occurred()) SWIG_fail;
20758 }
20759 {
20760 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20761 }
20762 return resultobj;
20763 fail:
20764 return NULL;
20765 }
20766
20767
20768 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20769 PyObject *resultobj = 0;
20770 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20771 bool result;
20772 void *argp1 = 0 ;
20773 int res1 = 0 ;
20774 PyObject *swig_obj[1] ;
20775
20776 if (!args) SWIG_fail;
20777 swig_obj[0] = args;
20778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20779 if (!SWIG_IsOK(res1)) {
20780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20781 }
20782 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20783 {
20784 PyThreadState* __tstate = wxPyBeginAllowThreads();
20785 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
20786 wxPyEndAllowThreads(__tstate);
20787 if (PyErr_Occurred()) SWIG_fail;
20788 }
20789 {
20790 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20791 }
20792 return resultobj;
20793 fail:
20794 return NULL;
20795 }
20796
20797
20798 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20799 PyObject *resultobj = 0;
20800 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20801 bool result;
20802 void *argp1 = 0 ;
20803 int res1 = 0 ;
20804 PyObject *swig_obj[1] ;
20805
20806 if (!args) SWIG_fail;
20807 swig_obj[0] = args;
20808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20809 if (!SWIG_IsOK(res1)) {
20810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20811 }
20812 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20813 {
20814 PyThreadState* __tstate = wxPyBeginAllowThreads();
20815 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
20816 wxPyEndAllowThreads(__tstate);
20817 if (PyErr_Occurred()) SWIG_fail;
20818 }
20819 {
20820 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20821 }
20822 return resultobj;
20823 fail:
20824 return NULL;
20825 }
20826
20827
20828 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20829 PyObject *resultobj = 0;
20830 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20831 bool result;
20832 void *argp1 = 0 ;
20833 int res1 = 0 ;
20834 PyObject *swig_obj[1] ;
20835
20836 if (!args) SWIG_fail;
20837 swig_obj[0] = args;
20838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20839 if (!SWIG_IsOK(res1)) {
20840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20841 }
20842 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20843 {
20844 PyThreadState* __tstate = wxPyBeginAllowThreads();
20845 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
20846 wxPyEndAllowThreads(__tstate);
20847 if (PyErr_Occurred()) SWIG_fail;
20848 }
20849 {
20850 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20851 }
20852 return resultobj;
20853 fail:
20854 return NULL;
20855 }
20856
20857
20858 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20859 PyObject *resultobj = 0;
20860 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20861 bool result;
20862 void *argp1 = 0 ;
20863 int res1 = 0 ;
20864 PyObject *swig_obj[1] ;
20865
20866 if (!args) SWIG_fail;
20867 swig_obj[0] = args;
20868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20869 if (!SWIG_IsOK(res1)) {
20870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20871 }
20872 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20873 {
20874 PyThreadState* __tstate = wxPyBeginAllowThreads();
20875 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
20876 wxPyEndAllowThreads(__tstate);
20877 if (PyErr_Occurred()) SWIG_fail;
20878 }
20879 {
20880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20881 }
20882 return resultobj;
20883 fail:
20884 return NULL;
20885 }
20886
20887
20888 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20889 PyObject *resultobj = 0;
20890 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20891 bool result;
20892 void *argp1 = 0 ;
20893 int res1 = 0 ;
20894 PyObject *swig_obj[1] ;
20895
20896 if (!args) SWIG_fail;
20897 swig_obj[0] = args;
20898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20899 if (!SWIG_IsOK(res1)) {
20900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20901 }
20902 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20903 {
20904 PyThreadState* __tstate = wxPyBeginAllowThreads();
20905 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
20906 wxPyEndAllowThreads(__tstate);
20907 if (PyErr_Occurred()) SWIG_fail;
20908 }
20909 {
20910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20911 }
20912 return resultobj;
20913 fail:
20914 return NULL;
20915 }
20916
20917
20918 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20919 PyObject *resultobj = 0;
20920 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20921 bool result;
20922 void *argp1 = 0 ;
20923 int res1 = 0 ;
20924 PyObject *swig_obj[1] ;
20925
20926 if (!args) SWIG_fail;
20927 swig_obj[0] = args;
20928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20929 if (!SWIG_IsOK(res1)) {
20930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20931 }
20932 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20933 {
20934 PyThreadState* __tstate = wxPyBeginAllowThreads();
20935 result = (bool)(arg1)->LeftIsDown();
20936 wxPyEndAllowThreads(__tstate);
20937 if (PyErr_Occurred()) SWIG_fail;
20938 }
20939 {
20940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20941 }
20942 return resultobj;
20943 fail:
20944 return NULL;
20945 }
20946
20947
20948 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20949 PyObject *resultobj = 0;
20950 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20951 bool result;
20952 void *argp1 = 0 ;
20953 int res1 = 0 ;
20954 PyObject *swig_obj[1] ;
20955
20956 if (!args) SWIG_fail;
20957 swig_obj[0] = args;
20958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20959 if (!SWIG_IsOK(res1)) {
20960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20961 }
20962 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20963 {
20964 PyThreadState* __tstate = wxPyBeginAllowThreads();
20965 result = (bool)(arg1)->MiddleIsDown();
20966 wxPyEndAllowThreads(__tstate);
20967 if (PyErr_Occurred()) SWIG_fail;
20968 }
20969 {
20970 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20971 }
20972 return resultobj;
20973 fail:
20974 return NULL;
20975 }
20976
20977
20978 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20979 PyObject *resultobj = 0;
20980 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20981 bool result;
20982 void *argp1 = 0 ;
20983 int res1 = 0 ;
20984 PyObject *swig_obj[1] ;
20985
20986 if (!args) SWIG_fail;
20987 swig_obj[0] = args;
20988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20989 if (!SWIG_IsOK(res1)) {
20990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20991 }
20992 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20993 {
20994 PyThreadState* __tstate = wxPyBeginAllowThreads();
20995 result = (bool)(arg1)->RightIsDown();
20996 wxPyEndAllowThreads(__tstate);
20997 if (PyErr_Occurred()) SWIG_fail;
20998 }
20999 {
21000 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21001 }
21002 return resultobj;
21003 fail:
21004 return NULL;
21005 }
21006
21007
21008 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21009 PyObject *resultobj = 0;
21010 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21011 bool result;
21012 void *argp1 = 0 ;
21013 int res1 = 0 ;
21014 PyObject *swig_obj[1] ;
21015
21016 if (!args) SWIG_fail;
21017 swig_obj[0] = args;
21018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21019 if (!SWIG_IsOK(res1)) {
21020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21021 }
21022 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21023 {
21024 PyThreadState* __tstate = wxPyBeginAllowThreads();
21025 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
21026 wxPyEndAllowThreads(__tstate);
21027 if (PyErr_Occurred()) SWIG_fail;
21028 }
21029 {
21030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21031 }
21032 return resultobj;
21033 fail:
21034 return NULL;
21035 }
21036
21037
21038 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21039 PyObject *resultobj = 0;
21040 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21041 bool result;
21042 void *argp1 = 0 ;
21043 int res1 = 0 ;
21044 PyObject *swig_obj[1] ;
21045
21046 if (!args) SWIG_fail;
21047 swig_obj[0] = args;
21048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21049 if (!SWIG_IsOK(res1)) {
21050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21051 }
21052 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21053 {
21054 PyThreadState* __tstate = wxPyBeginAllowThreads();
21055 result = (bool)((wxMouseEvent const *)arg1)->Moving();
21056 wxPyEndAllowThreads(__tstate);
21057 if (PyErr_Occurred()) SWIG_fail;
21058 }
21059 {
21060 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21061 }
21062 return resultobj;
21063 fail:
21064 return NULL;
21065 }
21066
21067
21068 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21069 PyObject *resultobj = 0;
21070 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21071 bool result;
21072 void *argp1 = 0 ;
21073 int res1 = 0 ;
21074 PyObject *swig_obj[1] ;
21075
21076 if (!args) SWIG_fail;
21077 swig_obj[0] = args;
21078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21079 if (!SWIG_IsOK(res1)) {
21080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21081 }
21082 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21083 {
21084 PyThreadState* __tstate = wxPyBeginAllowThreads();
21085 result = (bool)((wxMouseEvent const *)arg1)->Entering();
21086 wxPyEndAllowThreads(__tstate);
21087 if (PyErr_Occurred()) SWIG_fail;
21088 }
21089 {
21090 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21091 }
21092 return resultobj;
21093 fail:
21094 return NULL;
21095 }
21096
21097
21098 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21099 PyObject *resultobj = 0;
21100 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21101 bool result;
21102 void *argp1 = 0 ;
21103 int res1 = 0 ;
21104 PyObject *swig_obj[1] ;
21105
21106 if (!args) SWIG_fail;
21107 swig_obj[0] = args;
21108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21109 if (!SWIG_IsOK(res1)) {
21110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21111 }
21112 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21113 {
21114 PyThreadState* __tstate = wxPyBeginAllowThreads();
21115 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
21116 wxPyEndAllowThreads(__tstate);
21117 if (PyErr_Occurred()) SWIG_fail;
21118 }
21119 {
21120 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21121 }
21122 return resultobj;
21123 fail:
21124 return NULL;
21125 }
21126
21127
21128 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21129 PyObject *resultobj = 0;
21130 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21131 wxPoint result;
21132 void *argp1 = 0 ;
21133 int res1 = 0 ;
21134 PyObject *swig_obj[1] ;
21135
21136 if (!args) SWIG_fail;
21137 swig_obj[0] = args;
21138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21139 if (!SWIG_IsOK(res1)) {
21140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21141 }
21142 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21143 {
21144 PyThreadState* __tstate = wxPyBeginAllowThreads();
21145 result = (arg1)->GetPosition();
21146 wxPyEndAllowThreads(__tstate);
21147 if (PyErr_Occurred()) SWIG_fail;
21148 }
21149 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
21150 return resultobj;
21151 fail:
21152 return NULL;
21153 }
21154
21155
21156 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21157 PyObject *resultobj = 0;
21158 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21159 long *arg2 = (long *) 0 ;
21160 long *arg3 = (long *) 0 ;
21161 void *argp1 = 0 ;
21162 int res1 = 0 ;
21163 long temp2 ;
21164 int res2 = SWIG_TMPOBJ ;
21165 long temp3 ;
21166 int res3 = SWIG_TMPOBJ ;
21167 PyObject *swig_obj[1] ;
21168
21169 arg2 = &temp2;
21170 arg3 = &temp3;
21171 if (!args) SWIG_fail;
21172 swig_obj[0] = args;
21173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21174 if (!SWIG_IsOK(res1)) {
21175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21176 }
21177 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21178 {
21179 PyThreadState* __tstate = wxPyBeginAllowThreads();
21180 (arg1)->GetPosition(arg2,arg3);
21181 wxPyEndAllowThreads(__tstate);
21182 if (PyErr_Occurred()) SWIG_fail;
21183 }
21184 resultobj = SWIG_Py_Void();
21185 if (SWIG_IsTmpObj(res2)) {
21186 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
21187 } else {
21188 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21189 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
21190 }
21191 if (SWIG_IsTmpObj(res3)) {
21192 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
21193 } else {
21194 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21195 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
21196 }
21197 return resultobj;
21198 fail:
21199 return NULL;
21200 }
21201
21202
21203 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21204 PyObject *resultobj = 0;
21205 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21206 wxDC *arg2 = 0 ;
21207 wxPoint result;
21208 void *argp1 = 0 ;
21209 int res1 = 0 ;
21210 void *argp2 = 0 ;
21211 int res2 = 0 ;
21212 PyObject * obj0 = 0 ;
21213 PyObject * obj1 = 0 ;
21214 char * kwnames[] = {
21215 (char *) "self",(char *) "dc", NULL
21216 };
21217
21218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
21219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21220 if (!SWIG_IsOK(res1)) {
21221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21222 }
21223 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21224 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
21225 if (!SWIG_IsOK(res2)) {
21226 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
21227 }
21228 if (!argp2) {
21229 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
21230 }
21231 arg2 = reinterpret_cast< wxDC * >(argp2);
21232 {
21233 PyThreadState* __tstate = wxPyBeginAllowThreads();
21234 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
21235 wxPyEndAllowThreads(__tstate);
21236 if (PyErr_Occurred()) SWIG_fail;
21237 }
21238 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
21239 return resultobj;
21240 fail:
21241 return NULL;
21242 }
21243
21244
21245 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21246 PyObject *resultobj = 0;
21247 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21248 int result;
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_wxMouseEvent, 0 | 0 );
21256 if (!SWIG_IsOK(res1)) {
21257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21258 }
21259 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21260 {
21261 PyThreadState* __tstate = wxPyBeginAllowThreads();
21262 result = (int)((wxMouseEvent const *)arg1)->GetX();
21263 wxPyEndAllowThreads(__tstate);
21264 if (PyErr_Occurred()) SWIG_fail;
21265 }
21266 resultobj = SWIG_From_int(static_cast< int >(result));
21267 return resultobj;
21268 fail:
21269 return NULL;
21270 }
21271
21272
21273 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21274 PyObject *resultobj = 0;
21275 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21276 int result;
21277 void *argp1 = 0 ;
21278 int res1 = 0 ;
21279 PyObject *swig_obj[1] ;
21280
21281 if (!args) SWIG_fail;
21282 swig_obj[0] = args;
21283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21284 if (!SWIG_IsOK(res1)) {
21285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21286 }
21287 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21288 {
21289 PyThreadState* __tstate = wxPyBeginAllowThreads();
21290 result = (int)((wxMouseEvent const *)arg1)->GetY();
21291 wxPyEndAllowThreads(__tstate);
21292 if (PyErr_Occurred()) SWIG_fail;
21293 }
21294 resultobj = SWIG_From_int(static_cast< int >(result));
21295 return resultobj;
21296 fail:
21297 return NULL;
21298 }
21299
21300
21301 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21302 PyObject *resultobj = 0;
21303 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21304 int result;
21305 void *argp1 = 0 ;
21306 int res1 = 0 ;
21307 PyObject *swig_obj[1] ;
21308
21309 if (!args) SWIG_fail;
21310 swig_obj[0] = args;
21311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21312 if (!SWIG_IsOK(res1)) {
21313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21314 }
21315 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21316 {
21317 PyThreadState* __tstate = wxPyBeginAllowThreads();
21318 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
21319 wxPyEndAllowThreads(__tstate);
21320 if (PyErr_Occurred()) SWIG_fail;
21321 }
21322 resultobj = SWIG_From_int(static_cast< int >(result));
21323 return resultobj;
21324 fail:
21325 return NULL;
21326 }
21327
21328
21329 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21330 PyObject *resultobj = 0;
21331 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21332 int result;
21333 void *argp1 = 0 ;
21334 int res1 = 0 ;
21335 PyObject *swig_obj[1] ;
21336
21337 if (!args) SWIG_fail;
21338 swig_obj[0] = args;
21339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21340 if (!SWIG_IsOK(res1)) {
21341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21342 }
21343 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21344 {
21345 PyThreadState* __tstate = wxPyBeginAllowThreads();
21346 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
21347 wxPyEndAllowThreads(__tstate);
21348 if (PyErr_Occurred()) SWIG_fail;
21349 }
21350 resultobj = SWIG_From_int(static_cast< int >(result));
21351 return resultobj;
21352 fail:
21353 return NULL;
21354 }
21355
21356
21357 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21358 PyObject *resultobj = 0;
21359 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21360 int result;
21361 void *argp1 = 0 ;
21362 int res1 = 0 ;
21363 PyObject *swig_obj[1] ;
21364
21365 if (!args) SWIG_fail;
21366 swig_obj[0] = args;
21367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21368 if (!SWIG_IsOK(res1)) {
21369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21370 }
21371 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21372 {
21373 PyThreadState* __tstate = wxPyBeginAllowThreads();
21374 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
21375 wxPyEndAllowThreads(__tstate);
21376 if (PyErr_Occurred()) SWIG_fail;
21377 }
21378 resultobj = SWIG_From_int(static_cast< int >(result));
21379 return resultobj;
21380 fail:
21381 return NULL;
21382 }
21383
21384
21385 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21386 PyObject *resultobj = 0;
21387 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21388 bool result;
21389 void *argp1 = 0 ;
21390 int res1 = 0 ;
21391 PyObject *swig_obj[1] ;
21392
21393 if (!args) SWIG_fail;
21394 swig_obj[0] = args;
21395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21396 if (!SWIG_IsOK(res1)) {
21397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21398 }
21399 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21400 {
21401 PyThreadState* __tstate = wxPyBeginAllowThreads();
21402 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
21403 wxPyEndAllowThreads(__tstate);
21404 if (PyErr_Occurred()) SWIG_fail;
21405 }
21406 {
21407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21408 }
21409 return resultobj;
21410 fail:
21411 return NULL;
21412 }
21413
21414
21415 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21416 PyObject *resultobj = 0;
21417 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21418 int arg2 ;
21419 void *argp1 = 0 ;
21420 int res1 = 0 ;
21421 int val2 ;
21422 int ecode2 = 0 ;
21423 PyObject *swig_obj[2] ;
21424
21425 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
21426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21427 if (!SWIG_IsOK(res1)) {
21428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21429 }
21430 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21431 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21432 if (!SWIG_IsOK(ecode2)) {
21433 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
21434 }
21435 arg2 = static_cast< int >(val2);
21436 if (arg1) (arg1)->m_x = arg2;
21437
21438 resultobj = SWIG_Py_Void();
21439 return resultobj;
21440 fail:
21441 return NULL;
21442 }
21443
21444
21445 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21446 PyObject *resultobj = 0;
21447 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21448 int result;
21449 void *argp1 = 0 ;
21450 int res1 = 0 ;
21451 PyObject *swig_obj[1] ;
21452
21453 if (!args) SWIG_fail;
21454 swig_obj[0] = args;
21455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21456 if (!SWIG_IsOK(res1)) {
21457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21458 }
21459 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21460 result = (int) ((arg1)->m_x);
21461 resultobj = SWIG_From_int(static_cast< int >(result));
21462 return resultobj;
21463 fail:
21464 return NULL;
21465 }
21466
21467
21468 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21469 PyObject *resultobj = 0;
21470 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21471 int arg2 ;
21472 void *argp1 = 0 ;
21473 int res1 = 0 ;
21474 int val2 ;
21475 int ecode2 = 0 ;
21476 PyObject *swig_obj[2] ;
21477
21478 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
21479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21480 if (!SWIG_IsOK(res1)) {
21481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21482 }
21483 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21484 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21485 if (!SWIG_IsOK(ecode2)) {
21486 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21487 }
21488 arg2 = static_cast< int >(val2);
21489 if (arg1) (arg1)->m_y = arg2;
21490
21491 resultobj = SWIG_Py_Void();
21492 return resultobj;
21493 fail:
21494 return NULL;
21495 }
21496
21497
21498 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21499 PyObject *resultobj = 0;
21500 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21501 int result;
21502 void *argp1 = 0 ;
21503 int res1 = 0 ;
21504 PyObject *swig_obj[1] ;
21505
21506 if (!args) SWIG_fail;
21507 swig_obj[0] = args;
21508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21509 if (!SWIG_IsOK(res1)) {
21510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21511 }
21512 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21513 result = (int) ((arg1)->m_y);
21514 resultobj = SWIG_From_int(static_cast< int >(result));
21515 return resultobj;
21516 fail:
21517 return NULL;
21518 }
21519
21520
21521 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21522 PyObject *resultobj = 0;
21523 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21524 bool arg2 ;
21525 void *argp1 = 0 ;
21526 int res1 = 0 ;
21527 bool val2 ;
21528 int ecode2 = 0 ;
21529 PyObject *swig_obj[2] ;
21530
21531 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21533 if (!SWIG_IsOK(res1)) {
21534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21535 }
21536 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21537 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21538 if (!SWIG_IsOK(ecode2)) {
21539 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21540 }
21541 arg2 = static_cast< bool >(val2);
21542 if (arg1) (arg1)->m_leftDown = arg2;
21543
21544 resultobj = SWIG_Py_Void();
21545 return resultobj;
21546 fail:
21547 return NULL;
21548 }
21549
21550
21551 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21552 PyObject *resultobj = 0;
21553 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21554 bool result;
21555 void *argp1 = 0 ;
21556 int res1 = 0 ;
21557 PyObject *swig_obj[1] ;
21558
21559 if (!args) SWIG_fail;
21560 swig_obj[0] = args;
21561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21562 if (!SWIG_IsOK(res1)) {
21563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21564 }
21565 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21566 result = (bool) ((arg1)->m_leftDown);
21567 {
21568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21569 }
21570 return resultobj;
21571 fail:
21572 return NULL;
21573 }
21574
21575
21576 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21577 PyObject *resultobj = 0;
21578 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21579 bool arg2 ;
21580 void *argp1 = 0 ;
21581 int res1 = 0 ;
21582 bool val2 ;
21583 int ecode2 = 0 ;
21584 PyObject *swig_obj[2] ;
21585
21586 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21588 if (!SWIG_IsOK(res1)) {
21589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21590 }
21591 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21592 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21593 if (!SWIG_IsOK(ecode2)) {
21594 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21595 }
21596 arg2 = static_cast< bool >(val2);
21597 if (arg1) (arg1)->m_middleDown = arg2;
21598
21599 resultobj = SWIG_Py_Void();
21600 return resultobj;
21601 fail:
21602 return NULL;
21603 }
21604
21605
21606 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21607 PyObject *resultobj = 0;
21608 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21609 bool result;
21610 void *argp1 = 0 ;
21611 int res1 = 0 ;
21612 PyObject *swig_obj[1] ;
21613
21614 if (!args) SWIG_fail;
21615 swig_obj[0] = args;
21616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21617 if (!SWIG_IsOK(res1)) {
21618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21619 }
21620 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21621 result = (bool) ((arg1)->m_middleDown);
21622 {
21623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21624 }
21625 return resultobj;
21626 fail:
21627 return NULL;
21628 }
21629
21630
21631 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21632 PyObject *resultobj = 0;
21633 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21634 bool arg2 ;
21635 void *argp1 = 0 ;
21636 int res1 = 0 ;
21637 bool val2 ;
21638 int ecode2 = 0 ;
21639 PyObject *swig_obj[2] ;
21640
21641 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21643 if (!SWIG_IsOK(res1)) {
21644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21645 }
21646 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21647 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21648 if (!SWIG_IsOK(ecode2)) {
21649 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21650 }
21651 arg2 = static_cast< bool >(val2);
21652 if (arg1) (arg1)->m_rightDown = arg2;
21653
21654 resultobj = SWIG_Py_Void();
21655 return resultobj;
21656 fail:
21657 return NULL;
21658 }
21659
21660
21661 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21662 PyObject *resultobj = 0;
21663 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21664 bool result;
21665 void *argp1 = 0 ;
21666 int res1 = 0 ;
21667 PyObject *swig_obj[1] ;
21668
21669 if (!args) SWIG_fail;
21670 swig_obj[0] = args;
21671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21672 if (!SWIG_IsOK(res1)) {
21673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21674 }
21675 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21676 result = (bool) ((arg1)->m_rightDown);
21677 {
21678 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21679 }
21680 return resultobj;
21681 fail:
21682 return NULL;
21683 }
21684
21685
21686 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21687 PyObject *resultobj = 0;
21688 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21689 bool arg2 ;
21690 void *argp1 = 0 ;
21691 int res1 = 0 ;
21692 bool val2 ;
21693 int ecode2 = 0 ;
21694 PyObject *swig_obj[2] ;
21695
21696 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
21697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21698 if (!SWIG_IsOK(res1)) {
21699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21700 }
21701 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21702 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21703 if (!SWIG_IsOK(ecode2)) {
21704 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
21705 }
21706 arg2 = static_cast< bool >(val2);
21707 if (arg1) (arg1)->m_controlDown = arg2;
21708
21709 resultobj = SWIG_Py_Void();
21710 return resultobj;
21711 fail:
21712 return NULL;
21713 }
21714
21715
21716 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21717 PyObject *resultobj = 0;
21718 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21719 bool result;
21720 void *argp1 = 0 ;
21721 int res1 = 0 ;
21722 PyObject *swig_obj[1] ;
21723
21724 if (!args) SWIG_fail;
21725 swig_obj[0] = args;
21726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21727 if (!SWIG_IsOK(res1)) {
21728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21729 }
21730 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21731 result = (bool) ((arg1)->m_controlDown);
21732 {
21733 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21734 }
21735 return resultobj;
21736 fail:
21737 return NULL;
21738 }
21739
21740
21741 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21742 PyObject *resultobj = 0;
21743 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21744 bool arg2 ;
21745 void *argp1 = 0 ;
21746 int res1 = 0 ;
21747 bool val2 ;
21748 int ecode2 = 0 ;
21749 PyObject *swig_obj[2] ;
21750
21751 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
21752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21753 if (!SWIG_IsOK(res1)) {
21754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21755 }
21756 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21757 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21758 if (!SWIG_IsOK(ecode2)) {
21759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
21760 }
21761 arg2 = static_cast< bool >(val2);
21762 if (arg1) (arg1)->m_shiftDown = arg2;
21763
21764 resultobj = SWIG_Py_Void();
21765 return resultobj;
21766 fail:
21767 return NULL;
21768 }
21769
21770
21771 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21772 PyObject *resultobj = 0;
21773 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21774 bool result;
21775 void *argp1 = 0 ;
21776 int res1 = 0 ;
21777 PyObject *swig_obj[1] ;
21778
21779 if (!args) SWIG_fail;
21780 swig_obj[0] = args;
21781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21782 if (!SWIG_IsOK(res1)) {
21783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21784 }
21785 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21786 result = (bool) ((arg1)->m_shiftDown);
21787 {
21788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21789 }
21790 return resultobj;
21791 fail:
21792 return NULL;
21793 }
21794
21795
21796 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21797 PyObject *resultobj = 0;
21798 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21799 bool arg2 ;
21800 void *argp1 = 0 ;
21801 int res1 = 0 ;
21802 bool val2 ;
21803 int ecode2 = 0 ;
21804 PyObject *swig_obj[2] ;
21805
21806 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
21807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21808 if (!SWIG_IsOK(res1)) {
21809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21810 }
21811 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21812 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21813 if (!SWIG_IsOK(ecode2)) {
21814 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
21815 }
21816 arg2 = static_cast< bool >(val2);
21817 if (arg1) (arg1)->m_altDown = arg2;
21818
21819 resultobj = SWIG_Py_Void();
21820 return resultobj;
21821 fail:
21822 return NULL;
21823 }
21824
21825
21826 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21827 PyObject *resultobj = 0;
21828 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21829 bool result;
21830 void *argp1 = 0 ;
21831 int res1 = 0 ;
21832 PyObject *swig_obj[1] ;
21833
21834 if (!args) SWIG_fail;
21835 swig_obj[0] = args;
21836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21837 if (!SWIG_IsOK(res1)) {
21838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21839 }
21840 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21841 result = (bool) ((arg1)->m_altDown);
21842 {
21843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21844 }
21845 return resultobj;
21846 fail:
21847 return NULL;
21848 }
21849
21850
21851 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21852 PyObject *resultobj = 0;
21853 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21854 bool arg2 ;
21855 void *argp1 = 0 ;
21856 int res1 = 0 ;
21857 bool val2 ;
21858 int ecode2 = 0 ;
21859 PyObject *swig_obj[2] ;
21860
21861 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
21862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21863 if (!SWIG_IsOK(res1)) {
21864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21865 }
21866 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21867 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21868 if (!SWIG_IsOK(ecode2)) {
21869 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
21870 }
21871 arg2 = static_cast< bool >(val2);
21872 if (arg1) (arg1)->m_metaDown = arg2;
21873
21874 resultobj = SWIG_Py_Void();
21875 return resultobj;
21876 fail:
21877 return NULL;
21878 }
21879
21880
21881 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21882 PyObject *resultobj = 0;
21883 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21884 bool result;
21885 void *argp1 = 0 ;
21886 int res1 = 0 ;
21887 PyObject *swig_obj[1] ;
21888
21889 if (!args) SWIG_fail;
21890 swig_obj[0] = args;
21891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21892 if (!SWIG_IsOK(res1)) {
21893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21894 }
21895 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21896 result = (bool) ((arg1)->m_metaDown);
21897 {
21898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21899 }
21900 return resultobj;
21901 fail:
21902 return NULL;
21903 }
21904
21905
21906 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21907 PyObject *resultobj = 0;
21908 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21909 int arg2 ;
21910 void *argp1 = 0 ;
21911 int res1 = 0 ;
21912 int val2 ;
21913 int ecode2 = 0 ;
21914 PyObject *swig_obj[2] ;
21915
21916 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
21917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21918 if (!SWIG_IsOK(res1)) {
21919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21920 }
21921 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21922 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21923 if (!SWIG_IsOK(ecode2)) {
21924 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
21925 }
21926 arg2 = static_cast< int >(val2);
21927 if (arg1) (arg1)->m_wheelRotation = arg2;
21928
21929 resultobj = SWIG_Py_Void();
21930 return resultobj;
21931 fail:
21932 return NULL;
21933 }
21934
21935
21936 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21937 PyObject *resultobj = 0;
21938 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21939 int result;
21940 void *argp1 = 0 ;
21941 int res1 = 0 ;
21942 PyObject *swig_obj[1] ;
21943
21944 if (!args) SWIG_fail;
21945 swig_obj[0] = args;
21946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21947 if (!SWIG_IsOK(res1)) {
21948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21949 }
21950 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21951 result = (int) ((arg1)->m_wheelRotation);
21952 resultobj = SWIG_From_int(static_cast< int >(result));
21953 return resultobj;
21954 fail:
21955 return NULL;
21956 }
21957
21958
21959 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21960 PyObject *resultobj = 0;
21961 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21962 int arg2 ;
21963 void *argp1 = 0 ;
21964 int res1 = 0 ;
21965 int val2 ;
21966 int ecode2 = 0 ;
21967 PyObject *swig_obj[2] ;
21968
21969 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
21970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21971 if (!SWIG_IsOK(res1)) {
21972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21973 }
21974 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21975 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21976 if (!SWIG_IsOK(ecode2)) {
21977 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
21978 }
21979 arg2 = static_cast< int >(val2);
21980 if (arg1) (arg1)->m_wheelDelta = arg2;
21981
21982 resultobj = SWIG_Py_Void();
21983 return resultobj;
21984 fail:
21985 return NULL;
21986 }
21987
21988
21989 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21990 PyObject *resultobj = 0;
21991 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21992 int result;
21993 void *argp1 = 0 ;
21994 int res1 = 0 ;
21995 PyObject *swig_obj[1] ;
21996
21997 if (!args) SWIG_fail;
21998 swig_obj[0] = args;
21999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22000 if (!SWIG_IsOK(res1)) {
22001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22002 }
22003 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22004 result = (int) ((arg1)->m_wheelDelta);
22005 resultobj = SWIG_From_int(static_cast< int >(result));
22006 return resultobj;
22007 fail:
22008 return NULL;
22009 }
22010
22011
22012 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22013 PyObject *resultobj = 0;
22014 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22015 int arg2 ;
22016 void *argp1 = 0 ;
22017 int res1 = 0 ;
22018 int val2 ;
22019 int ecode2 = 0 ;
22020 PyObject *swig_obj[2] ;
22021
22022 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
22023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22024 if (!SWIG_IsOK(res1)) {
22025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22026 }
22027 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22028 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22029 if (!SWIG_IsOK(ecode2)) {
22030 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
22031 }
22032 arg2 = static_cast< int >(val2);
22033 if (arg1) (arg1)->m_linesPerAction = arg2;
22034
22035 resultobj = SWIG_Py_Void();
22036 return resultobj;
22037 fail:
22038 return NULL;
22039 }
22040
22041
22042 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22043 PyObject *resultobj = 0;
22044 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22045 int result;
22046 void *argp1 = 0 ;
22047 int res1 = 0 ;
22048 PyObject *swig_obj[1] ;
22049
22050 if (!args) SWIG_fail;
22051 swig_obj[0] = args;
22052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22053 if (!SWIG_IsOK(res1)) {
22054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
22055 }
22056 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22057 result = (int) ((arg1)->m_linesPerAction);
22058 resultobj = SWIG_From_int(static_cast< int >(result));
22059 return resultobj;
22060 fail:
22061 return NULL;
22062 }
22063
22064
22065 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22066 PyObject *obj;
22067 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22068 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
22069 return SWIG_Py_Void();
22070 }
22071
22072 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22073 return SWIG_Python_InitShadowInstance(args);
22074 }
22075
22076 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22077 PyObject *resultobj = 0;
22078 int arg1 = (int) 0 ;
22079 int arg2 = (int) 0 ;
22080 wxSetCursorEvent *result = 0 ;
22081 int val1 ;
22082 int ecode1 = 0 ;
22083 int val2 ;
22084 int ecode2 = 0 ;
22085 PyObject * obj0 = 0 ;
22086 PyObject * obj1 = 0 ;
22087 char * kwnames[] = {
22088 (char *) "x",(char *) "y", NULL
22089 };
22090
22091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22092 if (obj0) {
22093 ecode1 = SWIG_AsVal_int(obj0, &val1);
22094 if (!SWIG_IsOK(ecode1)) {
22095 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
22096 }
22097 arg1 = static_cast< int >(val1);
22098 }
22099 if (obj1) {
22100 ecode2 = SWIG_AsVal_int(obj1, &val2);
22101 if (!SWIG_IsOK(ecode2)) {
22102 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
22103 }
22104 arg2 = static_cast< int >(val2);
22105 }
22106 {
22107 PyThreadState* __tstate = wxPyBeginAllowThreads();
22108 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
22109 wxPyEndAllowThreads(__tstate);
22110 if (PyErr_Occurred()) SWIG_fail;
22111 }
22112 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
22113 return resultobj;
22114 fail:
22115 return NULL;
22116 }
22117
22118
22119 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22120 PyObject *resultobj = 0;
22121 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22122 int result;
22123 void *argp1 = 0 ;
22124 int res1 = 0 ;
22125 PyObject *swig_obj[1] ;
22126
22127 if (!args) SWIG_fail;
22128 swig_obj[0] = args;
22129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22130 if (!SWIG_IsOK(res1)) {
22131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22132 }
22133 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22134 {
22135 PyThreadState* __tstate = wxPyBeginAllowThreads();
22136 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
22137 wxPyEndAllowThreads(__tstate);
22138 if (PyErr_Occurred()) SWIG_fail;
22139 }
22140 resultobj = SWIG_From_int(static_cast< int >(result));
22141 return resultobj;
22142 fail:
22143 return NULL;
22144 }
22145
22146
22147 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22148 PyObject *resultobj = 0;
22149 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22150 int result;
22151 void *argp1 = 0 ;
22152 int res1 = 0 ;
22153 PyObject *swig_obj[1] ;
22154
22155 if (!args) SWIG_fail;
22156 swig_obj[0] = args;
22157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22158 if (!SWIG_IsOK(res1)) {
22159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22160 }
22161 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22162 {
22163 PyThreadState* __tstate = wxPyBeginAllowThreads();
22164 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
22165 wxPyEndAllowThreads(__tstate);
22166 if (PyErr_Occurred()) SWIG_fail;
22167 }
22168 resultobj = SWIG_From_int(static_cast< int >(result));
22169 return resultobj;
22170 fail:
22171 return NULL;
22172 }
22173
22174
22175 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22176 PyObject *resultobj = 0;
22177 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22178 wxCursor *arg2 = 0 ;
22179 void *argp1 = 0 ;
22180 int res1 = 0 ;
22181 void *argp2 = 0 ;
22182 int res2 = 0 ;
22183 PyObject * obj0 = 0 ;
22184 PyObject * obj1 = 0 ;
22185 char * kwnames[] = {
22186 (char *) "self",(char *) "cursor", NULL
22187 };
22188
22189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
22190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22191 if (!SWIG_IsOK(res1)) {
22192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
22193 }
22194 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22195 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
22196 if (!SWIG_IsOK(res2)) {
22197 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
22198 }
22199 if (!argp2) {
22200 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
22201 }
22202 arg2 = reinterpret_cast< wxCursor * >(argp2);
22203 {
22204 PyThreadState* __tstate = wxPyBeginAllowThreads();
22205 (arg1)->SetCursor((wxCursor const &)*arg2);
22206 wxPyEndAllowThreads(__tstate);
22207 if (PyErr_Occurred()) SWIG_fail;
22208 }
22209 resultobj = SWIG_Py_Void();
22210 return resultobj;
22211 fail:
22212 return NULL;
22213 }
22214
22215
22216 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22217 PyObject *resultobj = 0;
22218 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22219 wxCursor *result = 0 ;
22220 void *argp1 = 0 ;
22221 int res1 = 0 ;
22222 PyObject *swig_obj[1] ;
22223
22224 if (!args) SWIG_fail;
22225 swig_obj[0] = args;
22226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22227 if (!SWIG_IsOK(res1)) {
22228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22229 }
22230 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22231 {
22232 PyThreadState* __tstate = wxPyBeginAllowThreads();
22233 {
22234 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
22235 result = (wxCursor *) &_result_ref;
22236 }
22237 wxPyEndAllowThreads(__tstate);
22238 if (PyErr_Occurred()) SWIG_fail;
22239 }
22240 {
22241 wxCursor* resultptr = new wxCursor(*result);
22242 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
22243 }
22244 return resultobj;
22245 fail:
22246 return NULL;
22247 }
22248
22249
22250 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22251 PyObject *resultobj = 0;
22252 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22253 bool result;
22254 void *argp1 = 0 ;
22255 int res1 = 0 ;
22256 PyObject *swig_obj[1] ;
22257
22258 if (!args) SWIG_fail;
22259 swig_obj[0] = args;
22260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22261 if (!SWIG_IsOK(res1)) {
22262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22263 }
22264 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22265 {
22266 PyThreadState* __tstate = wxPyBeginAllowThreads();
22267 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
22268 wxPyEndAllowThreads(__tstate);
22269 if (PyErr_Occurred()) SWIG_fail;
22270 }
22271 {
22272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22273 }
22274 return resultobj;
22275 fail:
22276 return NULL;
22277 }
22278
22279
22280 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22281 PyObject *obj;
22282 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22283 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
22284 return SWIG_Py_Void();
22285 }
22286
22287 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22288 return SWIG_Python_InitShadowInstance(args);
22289 }
22290
22291 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22292 PyObject *resultobj = 0;
22293 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22294 wxKeyEvent *result = 0 ;
22295 int val1 ;
22296 int ecode1 = 0 ;
22297 PyObject * obj0 = 0 ;
22298 char * kwnames[] = {
22299 (char *) "eventType", NULL
22300 };
22301
22302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
22303 if (obj0) {
22304 ecode1 = SWIG_AsVal_int(obj0, &val1);
22305 if (!SWIG_IsOK(ecode1)) {
22306 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22307 }
22308 arg1 = static_cast< wxEventType >(val1);
22309 }
22310 {
22311 PyThreadState* __tstate = wxPyBeginAllowThreads();
22312 result = (wxKeyEvent *)new wxKeyEvent(arg1);
22313 wxPyEndAllowThreads(__tstate);
22314 if (PyErr_Occurred()) SWIG_fail;
22315 }
22316 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
22317 return resultobj;
22318 fail:
22319 return NULL;
22320 }
22321
22322
22323 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22324 PyObject *resultobj = 0;
22325 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22326 int result;
22327 void *argp1 = 0 ;
22328 int res1 = 0 ;
22329 PyObject *swig_obj[1] ;
22330
22331 if (!args) SWIG_fail;
22332 swig_obj[0] = args;
22333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22334 if (!SWIG_IsOK(res1)) {
22335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22336 }
22337 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22338 {
22339 PyThreadState* __tstate = wxPyBeginAllowThreads();
22340 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
22341 wxPyEndAllowThreads(__tstate);
22342 if (PyErr_Occurred()) SWIG_fail;
22343 }
22344 resultobj = SWIG_From_int(static_cast< int >(result));
22345 return resultobj;
22346 fail:
22347 return NULL;
22348 }
22349
22350
22351 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22352 PyObject *resultobj = 0;
22353 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22354 bool result;
22355 void *argp1 = 0 ;
22356 int res1 = 0 ;
22357 PyObject *swig_obj[1] ;
22358
22359 if (!args) SWIG_fail;
22360 swig_obj[0] = args;
22361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22362 if (!SWIG_IsOK(res1)) {
22363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22364 }
22365 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22366 {
22367 PyThreadState* __tstate = wxPyBeginAllowThreads();
22368 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
22369 wxPyEndAllowThreads(__tstate);
22370 if (PyErr_Occurred()) SWIG_fail;
22371 }
22372 {
22373 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22374 }
22375 return resultobj;
22376 fail:
22377 return NULL;
22378 }
22379
22380
22381 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22382 PyObject *resultobj = 0;
22383 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22384 bool result;
22385 void *argp1 = 0 ;
22386 int res1 = 0 ;
22387 PyObject *swig_obj[1] ;
22388
22389 if (!args) SWIG_fail;
22390 swig_obj[0] = args;
22391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22392 if (!SWIG_IsOK(res1)) {
22393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22394 }
22395 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22396 {
22397 PyThreadState* __tstate = wxPyBeginAllowThreads();
22398 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
22399 wxPyEndAllowThreads(__tstate);
22400 if (PyErr_Occurred()) SWIG_fail;
22401 }
22402 {
22403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22404 }
22405 return resultobj;
22406 fail:
22407 return NULL;
22408 }
22409
22410
22411 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22412 PyObject *resultobj = 0;
22413 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22414 bool result;
22415 void *argp1 = 0 ;
22416 int res1 = 0 ;
22417 PyObject *swig_obj[1] ;
22418
22419 if (!args) SWIG_fail;
22420 swig_obj[0] = args;
22421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22422 if (!SWIG_IsOK(res1)) {
22423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22424 }
22425 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22426 {
22427 PyThreadState* __tstate = wxPyBeginAllowThreads();
22428 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
22429 wxPyEndAllowThreads(__tstate);
22430 if (PyErr_Occurred()) SWIG_fail;
22431 }
22432 {
22433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22434 }
22435 return resultobj;
22436 fail:
22437 return NULL;
22438 }
22439
22440
22441 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22442 PyObject *resultobj = 0;
22443 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22444 bool result;
22445 void *argp1 = 0 ;
22446 int res1 = 0 ;
22447 PyObject *swig_obj[1] ;
22448
22449 if (!args) SWIG_fail;
22450 swig_obj[0] = args;
22451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22452 if (!SWIG_IsOK(res1)) {
22453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22454 }
22455 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22456 {
22457 PyThreadState* __tstate = wxPyBeginAllowThreads();
22458 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22459 wxPyEndAllowThreads(__tstate);
22460 if (PyErr_Occurred()) SWIG_fail;
22461 }
22462 {
22463 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22464 }
22465 return resultobj;
22466 fail:
22467 return NULL;
22468 }
22469
22470
22471 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22472 PyObject *resultobj = 0;
22473 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22474 bool result;
22475 void *argp1 = 0 ;
22476 int res1 = 0 ;
22477 PyObject *swig_obj[1] ;
22478
22479 if (!args) SWIG_fail;
22480 swig_obj[0] = args;
22481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22482 if (!SWIG_IsOK(res1)) {
22483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22484 }
22485 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22486 {
22487 PyThreadState* __tstate = wxPyBeginAllowThreads();
22488 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22489 wxPyEndAllowThreads(__tstate);
22490 if (PyErr_Occurred()) SWIG_fail;
22491 }
22492 {
22493 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22494 }
22495 return resultobj;
22496 fail:
22497 return NULL;
22498 }
22499
22500
22501 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22502 PyObject *resultobj = 0;
22503 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22504 bool result;
22505 void *argp1 = 0 ;
22506 int res1 = 0 ;
22507 PyObject *swig_obj[1] ;
22508
22509 if (!args) SWIG_fail;
22510 swig_obj[0] = args;
22511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22512 if (!SWIG_IsOK(res1)) {
22513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22514 }
22515 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22516 {
22517 PyThreadState* __tstate = wxPyBeginAllowThreads();
22518 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22519 wxPyEndAllowThreads(__tstate);
22520 if (PyErr_Occurred()) SWIG_fail;
22521 }
22522 {
22523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22524 }
22525 return resultobj;
22526 fail:
22527 return NULL;
22528 }
22529
22530
22531 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22532 PyObject *resultobj = 0;
22533 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22534 int result;
22535 void *argp1 = 0 ;
22536 int res1 = 0 ;
22537 PyObject *swig_obj[1] ;
22538
22539 if (!args) SWIG_fail;
22540 swig_obj[0] = args;
22541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22542 if (!SWIG_IsOK(res1)) {
22543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22544 }
22545 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22546 {
22547 PyThreadState* __tstate = wxPyBeginAllowThreads();
22548 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22549 wxPyEndAllowThreads(__tstate);
22550 if (PyErr_Occurred()) SWIG_fail;
22551 }
22552 resultobj = SWIG_From_int(static_cast< int >(result));
22553 return resultobj;
22554 fail:
22555 return NULL;
22556 }
22557
22558
22559 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22560 PyObject *resultobj = 0;
22561 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22562 int result;
22563 void *argp1 = 0 ;
22564 int res1 = 0 ;
22565 PyObject *swig_obj[1] ;
22566
22567 if (!args) SWIG_fail;
22568 swig_obj[0] = args;
22569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22570 if (!SWIG_IsOK(res1)) {
22571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22572 }
22573 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22574 {
22575 PyThreadState* __tstate = wxPyBeginAllowThreads();
22576 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
22577 wxPyEndAllowThreads(__tstate);
22578 if (PyErr_Occurred()) SWIG_fail;
22579 }
22580 resultobj = SWIG_From_int(static_cast< int >(result));
22581 return resultobj;
22582 fail:
22583 return NULL;
22584 }
22585
22586
22587 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22588 PyObject *resultobj = 0;
22589 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22590 int arg2 ;
22591 void *argp1 = 0 ;
22592 int res1 = 0 ;
22593 int val2 ;
22594 int ecode2 = 0 ;
22595 PyObject * obj0 = 0 ;
22596 PyObject * obj1 = 0 ;
22597 char * kwnames[] = {
22598 (char *) "self",(char *) "uniChar", NULL
22599 };
22600
22601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
22602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22603 if (!SWIG_IsOK(res1)) {
22604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22605 }
22606 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22607 ecode2 = SWIG_AsVal_int(obj1, &val2);
22608 if (!SWIG_IsOK(ecode2)) {
22609 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
22610 }
22611 arg2 = static_cast< int >(val2);
22612 {
22613 PyThreadState* __tstate = wxPyBeginAllowThreads();
22614 wxKeyEvent_SetUnicodeKey(arg1,arg2);
22615 wxPyEndAllowThreads(__tstate);
22616 if (PyErr_Occurred()) SWIG_fail;
22617 }
22618 resultobj = SWIG_Py_Void();
22619 return resultobj;
22620 fail:
22621 return NULL;
22622 }
22623
22624
22625 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22626 PyObject *resultobj = 0;
22627 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22628 unsigned int result;
22629 void *argp1 = 0 ;
22630 int res1 = 0 ;
22631 PyObject *swig_obj[1] ;
22632
22633 if (!args) SWIG_fail;
22634 swig_obj[0] = args;
22635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22636 if (!SWIG_IsOK(res1)) {
22637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22638 }
22639 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22640 {
22641 PyThreadState* __tstate = wxPyBeginAllowThreads();
22642 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22643 wxPyEndAllowThreads(__tstate);
22644 if (PyErr_Occurred()) SWIG_fail;
22645 }
22646 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22647 return resultobj;
22648 fail:
22649 return NULL;
22650 }
22651
22652
22653 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22654 PyObject *resultobj = 0;
22655 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22656 unsigned int result;
22657 void *argp1 = 0 ;
22658 int res1 = 0 ;
22659 PyObject *swig_obj[1] ;
22660
22661 if (!args) SWIG_fail;
22662 swig_obj[0] = args;
22663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22664 if (!SWIG_IsOK(res1)) {
22665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22666 }
22667 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22668 {
22669 PyThreadState* __tstate = wxPyBeginAllowThreads();
22670 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22671 wxPyEndAllowThreads(__tstate);
22672 if (PyErr_Occurred()) SWIG_fail;
22673 }
22674 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22675 return resultobj;
22676 fail:
22677 return NULL;
22678 }
22679
22680
22681 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22682 PyObject *resultobj = 0;
22683 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22684 wxPoint result;
22685 void *argp1 = 0 ;
22686 int res1 = 0 ;
22687 PyObject *swig_obj[1] ;
22688
22689 if (!args) SWIG_fail;
22690 swig_obj[0] = args;
22691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22692 if (!SWIG_IsOK(res1)) {
22693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22694 }
22695 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22696 {
22697 PyThreadState* __tstate = wxPyBeginAllowThreads();
22698 result = (arg1)->GetPosition();
22699 wxPyEndAllowThreads(__tstate);
22700 if (PyErr_Occurred()) SWIG_fail;
22701 }
22702 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22703 return resultobj;
22704 fail:
22705 return NULL;
22706 }
22707
22708
22709 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22710 PyObject *resultobj = 0;
22711 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22712 long *arg2 = (long *) 0 ;
22713 long *arg3 = (long *) 0 ;
22714 void *argp1 = 0 ;
22715 int res1 = 0 ;
22716 long temp2 ;
22717 int res2 = SWIG_TMPOBJ ;
22718 long temp3 ;
22719 int res3 = SWIG_TMPOBJ ;
22720 PyObject *swig_obj[1] ;
22721
22722 arg2 = &temp2;
22723 arg3 = &temp3;
22724 if (!args) SWIG_fail;
22725 swig_obj[0] = args;
22726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22727 if (!SWIG_IsOK(res1)) {
22728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22729 }
22730 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22731 {
22732 PyThreadState* __tstate = wxPyBeginAllowThreads();
22733 (arg1)->GetPosition(arg2,arg3);
22734 wxPyEndAllowThreads(__tstate);
22735 if (PyErr_Occurred()) SWIG_fail;
22736 }
22737 resultobj = SWIG_Py_Void();
22738 if (SWIG_IsTmpObj(res2)) {
22739 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
22740 } else {
22741 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22742 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
22743 }
22744 if (SWIG_IsTmpObj(res3)) {
22745 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
22746 } else {
22747 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22748 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
22749 }
22750 return resultobj;
22751 fail:
22752 return NULL;
22753 }
22754
22755
22756 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22757 PyObject *resultobj = 0;
22758 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22759 int result;
22760 void *argp1 = 0 ;
22761 int res1 = 0 ;
22762 PyObject *swig_obj[1] ;
22763
22764 if (!args) SWIG_fail;
22765 swig_obj[0] = args;
22766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22767 if (!SWIG_IsOK(res1)) {
22768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22769 }
22770 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22771 {
22772 PyThreadState* __tstate = wxPyBeginAllowThreads();
22773 result = (int)((wxKeyEvent const *)arg1)->GetX();
22774 wxPyEndAllowThreads(__tstate);
22775 if (PyErr_Occurred()) SWIG_fail;
22776 }
22777 resultobj = SWIG_From_int(static_cast< int >(result));
22778 return resultobj;
22779 fail:
22780 return NULL;
22781 }
22782
22783
22784 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22785 PyObject *resultobj = 0;
22786 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22787 int result;
22788 void *argp1 = 0 ;
22789 int res1 = 0 ;
22790 PyObject *swig_obj[1] ;
22791
22792 if (!args) SWIG_fail;
22793 swig_obj[0] = args;
22794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22795 if (!SWIG_IsOK(res1)) {
22796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22797 }
22798 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22799 {
22800 PyThreadState* __tstate = wxPyBeginAllowThreads();
22801 result = (int)((wxKeyEvent const *)arg1)->GetY();
22802 wxPyEndAllowThreads(__tstate);
22803 if (PyErr_Occurred()) SWIG_fail;
22804 }
22805 resultobj = SWIG_From_int(static_cast< int >(result));
22806 return resultobj;
22807 fail:
22808 return NULL;
22809 }
22810
22811
22812 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22813 PyObject *resultobj = 0;
22814 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22815 int arg2 ;
22816 void *argp1 = 0 ;
22817 int res1 = 0 ;
22818 int val2 ;
22819 int ecode2 = 0 ;
22820 PyObject *swig_obj[2] ;
22821
22822 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
22823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22824 if (!SWIG_IsOK(res1)) {
22825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22826 }
22827 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22828 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22829 if (!SWIG_IsOK(ecode2)) {
22830 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
22831 }
22832 arg2 = static_cast< int >(val2);
22833 if (arg1) (arg1)->m_x = arg2;
22834
22835 resultobj = SWIG_Py_Void();
22836 return resultobj;
22837 fail:
22838 return NULL;
22839 }
22840
22841
22842 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22843 PyObject *resultobj = 0;
22844 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22845 int result;
22846 void *argp1 = 0 ;
22847 int res1 = 0 ;
22848 PyObject *swig_obj[1] ;
22849
22850 if (!args) SWIG_fail;
22851 swig_obj[0] = args;
22852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22853 if (!SWIG_IsOK(res1)) {
22854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22855 }
22856 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22857 result = (int) ((arg1)->m_x);
22858 resultobj = SWIG_From_int(static_cast< int >(result));
22859 return resultobj;
22860 fail:
22861 return NULL;
22862 }
22863
22864
22865 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22866 PyObject *resultobj = 0;
22867 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22868 int arg2 ;
22869 void *argp1 = 0 ;
22870 int res1 = 0 ;
22871 int val2 ;
22872 int ecode2 = 0 ;
22873 PyObject *swig_obj[2] ;
22874
22875 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
22876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22877 if (!SWIG_IsOK(res1)) {
22878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22879 }
22880 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22881 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22882 if (!SWIG_IsOK(ecode2)) {
22883 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
22884 }
22885 arg2 = static_cast< int >(val2);
22886 if (arg1) (arg1)->m_y = arg2;
22887
22888 resultobj = SWIG_Py_Void();
22889 return resultobj;
22890 fail:
22891 return NULL;
22892 }
22893
22894
22895 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22896 PyObject *resultobj = 0;
22897 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22898 int result;
22899 void *argp1 = 0 ;
22900 int res1 = 0 ;
22901 PyObject *swig_obj[1] ;
22902
22903 if (!args) SWIG_fail;
22904 swig_obj[0] = args;
22905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22906 if (!SWIG_IsOK(res1)) {
22907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22908 }
22909 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22910 result = (int) ((arg1)->m_y);
22911 resultobj = SWIG_From_int(static_cast< int >(result));
22912 return resultobj;
22913 fail:
22914 return NULL;
22915 }
22916
22917
22918 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22919 PyObject *resultobj = 0;
22920 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22921 long arg2 ;
22922 void *argp1 = 0 ;
22923 int res1 = 0 ;
22924 long val2 ;
22925 int ecode2 = 0 ;
22926 PyObject *swig_obj[2] ;
22927
22928 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
22929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22930 if (!SWIG_IsOK(res1)) {
22931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22932 }
22933 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22934 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
22935 if (!SWIG_IsOK(ecode2)) {
22936 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
22937 }
22938 arg2 = static_cast< long >(val2);
22939 if (arg1) (arg1)->m_keyCode = arg2;
22940
22941 resultobj = SWIG_Py_Void();
22942 return resultobj;
22943 fail:
22944 return NULL;
22945 }
22946
22947
22948 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22949 PyObject *resultobj = 0;
22950 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22951 long result;
22952 void *argp1 = 0 ;
22953 int res1 = 0 ;
22954 PyObject *swig_obj[1] ;
22955
22956 if (!args) SWIG_fail;
22957 swig_obj[0] = args;
22958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22959 if (!SWIG_IsOK(res1)) {
22960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22961 }
22962 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22963 result = (long) ((arg1)->m_keyCode);
22964 resultobj = SWIG_From_long(static_cast< long >(result));
22965 return resultobj;
22966 fail:
22967 return NULL;
22968 }
22969
22970
22971 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22972 PyObject *resultobj = 0;
22973 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22974 bool arg2 ;
22975 void *argp1 = 0 ;
22976 int res1 = 0 ;
22977 bool val2 ;
22978 int ecode2 = 0 ;
22979 PyObject *swig_obj[2] ;
22980
22981 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22983 if (!SWIG_IsOK(res1)) {
22984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22985 }
22986 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22987 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22988 if (!SWIG_IsOK(ecode2)) {
22989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22990 }
22991 arg2 = static_cast< bool >(val2);
22992 if (arg1) (arg1)->m_controlDown = arg2;
22993
22994 resultobj = SWIG_Py_Void();
22995 return resultobj;
22996 fail:
22997 return NULL;
22998 }
22999
23000
23001 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23002 PyObject *resultobj = 0;
23003 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23004 bool result;
23005 void *argp1 = 0 ;
23006 int res1 = 0 ;
23007 PyObject *swig_obj[1] ;
23008
23009 if (!args) SWIG_fail;
23010 swig_obj[0] = args;
23011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23012 if (!SWIG_IsOK(res1)) {
23013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23014 }
23015 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23016 result = (bool) ((arg1)->m_controlDown);
23017 {
23018 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23019 }
23020 return resultobj;
23021 fail:
23022 return NULL;
23023 }
23024
23025
23026 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23027 PyObject *resultobj = 0;
23028 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23029 bool arg2 ;
23030 void *argp1 = 0 ;
23031 int res1 = 0 ;
23032 bool val2 ;
23033 int ecode2 = 0 ;
23034 PyObject *swig_obj[2] ;
23035
23036 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
23037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23038 if (!SWIG_IsOK(res1)) {
23039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23040 }
23041 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23042 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23043 if (!SWIG_IsOK(ecode2)) {
23044 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
23045 }
23046 arg2 = static_cast< bool >(val2);
23047 if (arg1) (arg1)->m_shiftDown = arg2;
23048
23049 resultobj = SWIG_Py_Void();
23050 return resultobj;
23051 fail:
23052 return NULL;
23053 }
23054
23055
23056 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23057 PyObject *resultobj = 0;
23058 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23059 bool result;
23060 void *argp1 = 0 ;
23061 int res1 = 0 ;
23062 PyObject *swig_obj[1] ;
23063
23064 if (!args) SWIG_fail;
23065 swig_obj[0] = args;
23066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23067 if (!SWIG_IsOK(res1)) {
23068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23069 }
23070 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23071 result = (bool) ((arg1)->m_shiftDown);
23072 {
23073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23074 }
23075 return resultobj;
23076 fail:
23077 return NULL;
23078 }
23079
23080
23081 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23082 PyObject *resultobj = 0;
23083 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23084 bool arg2 ;
23085 void *argp1 = 0 ;
23086 int res1 = 0 ;
23087 bool val2 ;
23088 int ecode2 = 0 ;
23089 PyObject *swig_obj[2] ;
23090
23091 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
23092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23093 if (!SWIG_IsOK(res1)) {
23094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23095 }
23096 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23097 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23098 if (!SWIG_IsOK(ecode2)) {
23099 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
23100 }
23101 arg2 = static_cast< bool >(val2);
23102 if (arg1) (arg1)->m_altDown = arg2;
23103
23104 resultobj = SWIG_Py_Void();
23105 return resultobj;
23106 fail:
23107 return NULL;
23108 }
23109
23110
23111 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23112 PyObject *resultobj = 0;
23113 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23114 bool result;
23115 void *argp1 = 0 ;
23116 int res1 = 0 ;
23117 PyObject *swig_obj[1] ;
23118
23119 if (!args) SWIG_fail;
23120 swig_obj[0] = args;
23121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23122 if (!SWIG_IsOK(res1)) {
23123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23124 }
23125 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23126 result = (bool) ((arg1)->m_altDown);
23127 {
23128 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23129 }
23130 return resultobj;
23131 fail:
23132 return NULL;
23133 }
23134
23135
23136 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23137 PyObject *resultobj = 0;
23138 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23139 bool arg2 ;
23140 void *argp1 = 0 ;
23141 int res1 = 0 ;
23142 bool val2 ;
23143 int ecode2 = 0 ;
23144 PyObject *swig_obj[2] ;
23145
23146 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
23147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23148 if (!SWIG_IsOK(res1)) {
23149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23150 }
23151 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23152 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23153 if (!SWIG_IsOK(ecode2)) {
23154 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
23155 }
23156 arg2 = static_cast< bool >(val2);
23157 if (arg1) (arg1)->m_metaDown = arg2;
23158
23159 resultobj = SWIG_Py_Void();
23160 return resultobj;
23161 fail:
23162 return NULL;
23163 }
23164
23165
23166 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23167 PyObject *resultobj = 0;
23168 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23169 bool result;
23170 void *argp1 = 0 ;
23171 int res1 = 0 ;
23172 PyObject *swig_obj[1] ;
23173
23174 if (!args) SWIG_fail;
23175 swig_obj[0] = args;
23176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23177 if (!SWIG_IsOK(res1)) {
23178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23179 }
23180 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23181 result = (bool) ((arg1)->m_metaDown);
23182 {
23183 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23184 }
23185 return resultobj;
23186 fail:
23187 return NULL;
23188 }
23189
23190
23191 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23192 PyObject *resultobj = 0;
23193 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23194 bool arg2 ;
23195 void *argp1 = 0 ;
23196 int res1 = 0 ;
23197 bool val2 ;
23198 int ecode2 = 0 ;
23199 PyObject *swig_obj[2] ;
23200
23201 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
23202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23203 if (!SWIG_IsOK(res1)) {
23204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23205 }
23206 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23207 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23208 if (!SWIG_IsOK(ecode2)) {
23209 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
23210 }
23211 arg2 = static_cast< bool >(val2);
23212 if (arg1) (arg1)->m_scanCode = arg2;
23213
23214 resultobj = SWIG_Py_Void();
23215 return resultobj;
23216 fail:
23217 return NULL;
23218 }
23219
23220
23221 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23222 PyObject *resultobj = 0;
23223 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23224 bool result;
23225 void *argp1 = 0 ;
23226 int res1 = 0 ;
23227 PyObject *swig_obj[1] ;
23228
23229 if (!args) SWIG_fail;
23230 swig_obj[0] = args;
23231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23232 if (!SWIG_IsOK(res1)) {
23233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23234 }
23235 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23236 result = (bool) ((arg1)->m_scanCode);
23237 {
23238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23239 }
23240 return resultobj;
23241 fail:
23242 return NULL;
23243 }
23244
23245
23246 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23247 PyObject *resultobj = 0;
23248 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23249 unsigned int arg2 ;
23250 void *argp1 = 0 ;
23251 int res1 = 0 ;
23252 unsigned int val2 ;
23253 int ecode2 = 0 ;
23254 PyObject *swig_obj[2] ;
23255
23256 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
23257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23258 if (!SWIG_IsOK(res1)) {
23259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23260 }
23261 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23262 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
23263 if (!SWIG_IsOK(ecode2)) {
23264 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
23265 }
23266 arg2 = static_cast< unsigned int >(val2);
23267 if (arg1) (arg1)->m_rawCode = arg2;
23268
23269 resultobj = SWIG_Py_Void();
23270 return resultobj;
23271 fail:
23272 return NULL;
23273 }
23274
23275
23276 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23277 PyObject *resultobj = 0;
23278 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23279 unsigned int result;
23280 void *argp1 = 0 ;
23281 int res1 = 0 ;
23282 PyObject *swig_obj[1] ;
23283
23284 if (!args) SWIG_fail;
23285 swig_obj[0] = args;
23286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23287 if (!SWIG_IsOK(res1)) {
23288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23289 }
23290 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23291 result = (unsigned int) ((arg1)->m_rawCode);
23292 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23293 return resultobj;
23294 fail:
23295 return NULL;
23296 }
23297
23298
23299 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23300 PyObject *resultobj = 0;
23301 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23302 unsigned int arg2 ;
23303 void *argp1 = 0 ;
23304 int res1 = 0 ;
23305 unsigned int val2 ;
23306 int ecode2 = 0 ;
23307 PyObject *swig_obj[2] ;
23308
23309 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
23310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23311 if (!SWIG_IsOK(res1)) {
23312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23313 }
23314 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23315 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
23316 if (!SWIG_IsOK(ecode2)) {
23317 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
23318 }
23319 arg2 = static_cast< unsigned int >(val2);
23320 if (arg1) (arg1)->m_rawFlags = arg2;
23321
23322 resultobj = SWIG_Py_Void();
23323 return resultobj;
23324 fail:
23325 return NULL;
23326 }
23327
23328
23329 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23330 PyObject *resultobj = 0;
23331 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23332 unsigned int result;
23333 void *argp1 = 0 ;
23334 int res1 = 0 ;
23335 PyObject *swig_obj[1] ;
23336
23337 if (!args) SWIG_fail;
23338 swig_obj[0] = args;
23339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23340 if (!SWIG_IsOK(res1)) {
23341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23342 }
23343 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23344 result = (unsigned int) ((arg1)->m_rawFlags);
23345 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23346 return resultobj;
23347 fail:
23348 return NULL;
23349 }
23350
23351
23352 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23353 PyObject *obj;
23354 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23355 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
23356 return SWIG_Py_Void();
23357 }
23358
23359 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23360 return SWIG_Python_InitShadowInstance(args);
23361 }
23362
23363 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23364 PyObject *resultobj = 0;
23365 wxSize const &arg1_defvalue = wxDefaultSize ;
23366 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
23367 int arg2 = (int) 0 ;
23368 wxSizeEvent *result = 0 ;
23369 wxSize temp1 ;
23370 int val2 ;
23371 int ecode2 = 0 ;
23372 PyObject * obj0 = 0 ;
23373 PyObject * obj1 = 0 ;
23374 char * kwnames[] = {
23375 (char *) "sz",(char *) "winid", NULL
23376 };
23377
23378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23379 if (obj0) {
23380 {
23381 arg1 = &temp1;
23382 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
23383 }
23384 }
23385 if (obj1) {
23386 ecode2 = SWIG_AsVal_int(obj1, &val2);
23387 if (!SWIG_IsOK(ecode2)) {
23388 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
23389 }
23390 arg2 = static_cast< int >(val2);
23391 }
23392 {
23393 PyThreadState* __tstate = wxPyBeginAllowThreads();
23394 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
23395 wxPyEndAllowThreads(__tstate);
23396 if (PyErr_Occurred()) SWIG_fail;
23397 }
23398 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
23399 return resultobj;
23400 fail:
23401 return NULL;
23402 }
23403
23404
23405 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23406 PyObject *resultobj = 0;
23407 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23408 wxSize result;
23409 void *argp1 = 0 ;
23410 int res1 = 0 ;
23411 PyObject *swig_obj[1] ;
23412
23413 if (!args) SWIG_fail;
23414 swig_obj[0] = args;
23415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23416 if (!SWIG_IsOK(res1)) {
23417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23418 }
23419 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23420 {
23421 PyThreadState* __tstate = wxPyBeginAllowThreads();
23422 result = ((wxSizeEvent const *)arg1)->GetSize();
23423 wxPyEndAllowThreads(__tstate);
23424 if (PyErr_Occurred()) SWIG_fail;
23425 }
23426 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
23427 return resultobj;
23428 fail:
23429 return NULL;
23430 }
23431
23432
23433 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23434 PyObject *resultobj = 0;
23435 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23436 wxRect result;
23437 void *argp1 = 0 ;
23438 int res1 = 0 ;
23439 PyObject *swig_obj[1] ;
23440
23441 if (!args) SWIG_fail;
23442 swig_obj[0] = args;
23443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23444 if (!SWIG_IsOK(res1)) {
23445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23446 }
23447 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23448 {
23449 PyThreadState* __tstate = wxPyBeginAllowThreads();
23450 result = ((wxSizeEvent const *)arg1)->GetRect();
23451 wxPyEndAllowThreads(__tstate);
23452 if (PyErr_Occurred()) SWIG_fail;
23453 }
23454 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23455 return resultobj;
23456 fail:
23457 return NULL;
23458 }
23459
23460
23461 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23462 PyObject *resultobj = 0;
23463 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23464 wxRect arg2 ;
23465 void *argp1 = 0 ;
23466 int res1 = 0 ;
23467 void *argp2 ;
23468 int res2 = 0 ;
23469 PyObject * obj0 = 0 ;
23470 PyObject * obj1 = 0 ;
23471 char * kwnames[] = {
23472 (char *) "self",(char *) "rect", NULL
23473 };
23474
23475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23477 if (!SWIG_IsOK(res1)) {
23478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23479 }
23480 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23481 {
23482 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
23483 if (!SWIG_IsOK(res2)) {
23484 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23485 }
23486 if (!argp2) {
23487 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23488 } else {
23489 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
23490 arg2 = *temp;
23491 if (SWIG_IsNewObj(res2)) delete temp;
23492 }
23493 }
23494 {
23495 PyThreadState* __tstate = wxPyBeginAllowThreads();
23496 (arg1)->SetRect(arg2);
23497 wxPyEndAllowThreads(__tstate);
23498 if (PyErr_Occurred()) SWIG_fail;
23499 }
23500 resultobj = SWIG_Py_Void();
23501 return resultobj;
23502 fail:
23503 return NULL;
23504 }
23505
23506
23507 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23508 PyObject *resultobj = 0;
23509 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23510 wxSize arg2 ;
23511 void *argp1 = 0 ;
23512 int res1 = 0 ;
23513 void *argp2 ;
23514 int res2 = 0 ;
23515 PyObject * obj0 = 0 ;
23516 PyObject * obj1 = 0 ;
23517 char * kwnames[] = {
23518 (char *) "self",(char *) "size", NULL
23519 };
23520
23521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23523 if (!SWIG_IsOK(res1)) {
23524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23525 }
23526 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23527 {
23528 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23529 if (!SWIG_IsOK(res2)) {
23530 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23531 }
23532 if (!argp2) {
23533 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23534 } else {
23535 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23536 arg2 = *temp;
23537 if (SWIG_IsNewObj(res2)) delete temp;
23538 }
23539 }
23540 {
23541 PyThreadState* __tstate = wxPyBeginAllowThreads();
23542 wxSizeEvent_SetSize(arg1,arg2);
23543 wxPyEndAllowThreads(__tstate);
23544 if (PyErr_Occurred()) SWIG_fail;
23545 }
23546 resultobj = SWIG_Py_Void();
23547 return resultobj;
23548 fail:
23549 return NULL;
23550 }
23551
23552
23553 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23554 PyObject *resultobj = 0;
23555 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23556 wxSize *arg2 = (wxSize *) 0 ;
23557 void *argp1 = 0 ;
23558 int res1 = 0 ;
23559 void *argp2 = 0 ;
23560 int res2 = 0 ;
23561 PyObject *swig_obj[2] ;
23562
23563 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
23564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23565 if (!SWIG_IsOK(res1)) {
23566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23567 }
23568 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23569 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23570 if (!SWIG_IsOK(res2)) {
23571 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23572 }
23573 arg2 = reinterpret_cast< wxSize * >(argp2);
23574 if (arg1) (arg1)->m_size = *arg2;
23575
23576 resultobj = SWIG_Py_Void();
23577 return resultobj;
23578 fail:
23579 return NULL;
23580 }
23581
23582
23583 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23584 PyObject *resultobj = 0;
23585 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23586 wxSize *result = 0 ;
23587 void *argp1 = 0 ;
23588 int res1 = 0 ;
23589 PyObject *swig_obj[1] ;
23590
23591 if (!args) SWIG_fail;
23592 swig_obj[0] = args;
23593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23594 if (!SWIG_IsOK(res1)) {
23595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23596 }
23597 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23598 result = (wxSize *)& ((arg1)->m_size);
23599 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23600 return resultobj;
23601 fail:
23602 return NULL;
23603 }
23604
23605
23606 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23607 PyObject *resultobj = 0;
23608 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23609 wxRect *arg2 = (wxRect *) 0 ;
23610 void *argp1 = 0 ;
23611 int res1 = 0 ;
23612 void *argp2 = 0 ;
23613 int res2 = 0 ;
23614 PyObject *swig_obj[2] ;
23615
23616 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23618 if (!SWIG_IsOK(res1)) {
23619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23620 }
23621 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23622 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23623 if (!SWIG_IsOK(res2)) {
23624 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23625 }
23626 arg2 = reinterpret_cast< wxRect * >(argp2);
23627 if (arg1) (arg1)->m_rect = *arg2;
23628
23629 resultobj = SWIG_Py_Void();
23630 return resultobj;
23631 fail:
23632 return NULL;
23633 }
23634
23635
23636 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23637 PyObject *resultobj = 0;
23638 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23639 wxRect *result = 0 ;
23640 void *argp1 = 0 ;
23641 int res1 = 0 ;
23642 PyObject *swig_obj[1] ;
23643
23644 if (!args) SWIG_fail;
23645 swig_obj[0] = args;
23646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23647 if (!SWIG_IsOK(res1)) {
23648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23649 }
23650 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23651 result = (wxRect *)& ((arg1)->m_rect);
23652 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23653 return resultobj;
23654 fail:
23655 return NULL;
23656 }
23657
23658
23659 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23660 PyObject *obj;
23661 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23662 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23663 return SWIG_Py_Void();
23664 }
23665
23666 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23667 return SWIG_Python_InitShadowInstance(args);
23668 }
23669
23670 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23671 PyObject *resultobj = 0;
23672 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23673 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23674 int arg2 = (int) 0 ;
23675 wxMoveEvent *result = 0 ;
23676 wxPoint temp1 ;
23677 int val2 ;
23678 int ecode2 = 0 ;
23679 PyObject * obj0 = 0 ;
23680 PyObject * obj1 = 0 ;
23681 char * kwnames[] = {
23682 (char *) "pos",(char *) "winid", NULL
23683 };
23684
23685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23686 if (obj0) {
23687 {
23688 arg1 = &temp1;
23689 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
23690 }
23691 }
23692 if (obj1) {
23693 ecode2 = SWIG_AsVal_int(obj1, &val2);
23694 if (!SWIG_IsOK(ecode2)) {
23695 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
23696 }
23697 arg2 = static_cast< int >(val2);
23698 }
23699 {
23700 PyThreadState* __tstate = wxPyBeginAllowThreads();
23701 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
23702 wxPyEndAllowThreads(__tstate);
23703 if (PyErr_Occurred()) SWIG_fail;
23704 }
23705 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
23706 return resultobj;
23707 fail:
23708 return NULL;
23709 }
23710
23711
23712 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23713 PyObject *resultobj = 0;
23714 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23715 wxPoint result;
23716 void *argp1 = 0 ;
23717 int res1 = 0 ;
23718 PyObject *swig_obj[1] ;
23719
23720 if (!args) SWIG_fail;
23721 swig_obj[0] = args;
23722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23723 if (!SWIG_IsOK(res1)) {
23724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23725 }
23726 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23727 {
23728 PyThreadState* __tstate = wxPyBeginAllowThreads();
23729 result = ((wxMoveEvent const *)arg1)->GetPosition();
23730 wxPyEndAllowThreads(__tstate);
23731 if (PyErr_Occurred()) SWIG_fail;
23732 }
23733 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23734 return resultobj;
23735 fail:
23736 return NULL;
23737 }
23738
23739
23740 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23741 PyObject *resultobj = 0;
23742 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23743 wxRect result;
23744 void *argp1 = 0 ;
23745 int res1 = 0 ;
23746 PyObject *swig_obj[1] ;
23747
23748 if (!args) SWIG_fail;
23749 swig_obj[0] = args;
23750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23751 if (!SWIG_IsOK(res1)) {
23752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23753 }
23754 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23755 {
23756 PyThreadState* __tstate = wxPyBeginAllowThreads();
23757 result = ((wxMoveEvent const *)arg1)->GetRect();
23758 wxPyEndAllowThreads(__tstate);
23759 if (PyErr_Occurred()) SWIG_fail;
23760 }
23761 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23762 return resultobj;
23763 fail:
23764 return NULL;
23765 }
23766
23767
23768 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23769 PyObject *resultobj = 0;
23770 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23771 wxRect *arg2 = 0 ;
23772 void *argp1 = 0 ;
23773 int res1 = 0 ;
23774 wxRect temp2 ;
23775 PyObject * obj0 = 0 ;
23776 PyObject * obj1 = 0 ;
23777 char * kwnames[] = {
23778 (char *) "self",(char *) "rect", NULL
23779 };
23780
23781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23783 if (!SWIG_IsOK(res1)) {
23784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23785 }
23786 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23787 {
23788 arg2 = &temp2;
23789 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23790 }
23791 {
23792 PyThreadState* __tstate = wxPyBeginAllowThreads();
23793 (arg1)->SetRect((wxRect const &)*arg2);
23794 wxPyEndAllowThreads(__tstate);
23795 if (PyErr_Occurred()) SWIG_fail;
23796 }
23797 resultobj = SWIG_Py_Void();
23798 return resultobj;
23799 fail:
23800 return NULL;
23801 }
23802
23803
23804 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23805 PyObject *resultobj = 0;
23806 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23807 wxPoint *arg2 = 0 ;
23808 void *argp1 = 0 ;
23809 int res1 = 0 ;
23810 wxPoint temp2 ;
23811 PyObject * obj0 = 0 ;
23812 PyObject * obj1 = 0 ;
23813 char * kwnames[] = {
23814 (char *) "self",(char *) "pos", NULL
23815 };
23816
23817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23819 if (!SWIG_IsOK(res1)) {
23820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23821 }
23822 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23823 {
23824 arg2 = &temp2;
23825 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23826 }
23827 {
23828 PyThreadState* __tstate = wxPyBeginAllowThreads();
23829 (arg1)->SetPosition((wxPoint const &)*arg2);
23830 wxPyEndAllowThreads(__tstate);
23831 if (PyErr_Occurred()) SWIG_fail;
23832 }
23833 resultobj = SWIG_Py_Void();
23834 return resultobj;
23835 fail:
23836 return NULL;
23837 }
23838
23839
23840 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23841 PyObject *obj;
23842 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23843 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
23844 return SWIG_Py_Void();
23845 }
23846
23847 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23848 return SWIG_Python_InitShadowInstance(args);
23849 }
23850
23851 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23852 PyObject *resultobj = 0;
23853 int arg1 = (int) 0 ;
23854 wxPaintEvent *result = 0 ;
23855 int val1 ;
23856 int ecode1 = 0 ;
23857 PyObject * obj0 = 0 ;
23858 char * kwnames[] = {
23859 (char *) "Id", NULL
23860 };
23861
23862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
23863 if (obj0) {
23864 ecode1 = SWIG_AsVal_int(obj0, &val1);
23865 if (!SWIG_IsOK(ecode1)) {
23866 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
23867 }
23868 arg1 = static_cast< int >(val1);
23869 }
23870 {
23871 PyThreadState* __tstate = wxPyBeginAllowThreads();
23872 result = (wxPaintEvent *)new wxPaintEvent(arg1);
23873 wxPyEndAllowThreads(__tstate);
23874 if (PyErr_Occurred()) SWIG_fail;
23875 }
23876 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
23877 return resultobj;
23878 fail:
23879 return NULL;
23880 }
23881
23882
23883 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23884 PyObject *obj;
23885 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23886 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
23887 return SWIG_Py_Void();
23888 }
23889
23890 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23891 return SWIG_Python_InitShadowInstance(args);
23892 }
23893
23894 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23895 PyObject *resultobj = 0;
23896 int arg1 = (int) 0 ;
23897 wxNcPaintEvent *result = 0 ;
23898 int val1 ;
23899 int ecode1 = 0 ;
23900 PyObject * obj0 = 0 ;
23901 char * kwnames[] = {
23902 (char *) "winid", NULL
23903 };
23904
23905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
23906 if (obj0) {
23907 ecode1 = SWIG_AsVal_int(obj0, &val1);
23908 if (!SWIG_IsOK(ecode1)) {
23909 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
23910 }
23911 arg1 = static_cast< int >(val1);
23912 }
23913 {
23914 PyThreadState* __tstate = wxPyBeginAllowThreads();
23915 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
23916 wxPyEndAllowThreads(__tstate);
23917 if (PyErr_Occurred()) SWIG_fail;
23918 }
23919 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
23920 return resultobj;
23921 fail:
23922 return NULL;
23923 }
23924
23925
23926 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23927 PyObject *obj;
23928 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23929 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
23930 return SWIG_Py_Void();
23931 }
23932
23933 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23934 return SWIG_Python_InitShadowInstance(args);
23935 }
23936
23937 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23938 PyObject *resultobj = 0;
23939 int arg1 = (int) 0 ;
23940 wxDC *arg2 = (wxDC *) NULL ;
23941 wxEraseEvent *result = 0 ;
23942 int val1 ;
23943 int ecode1 = 0 ;
23944 void *argp2 = 0 ;
23945 int res2 = 0 ;
23946 PyObject * obj0 = 0 ;
23947 PyObject * obj1 = 0 ;
23948 char * kwnames[] = {
23949 (char *) "Id",(char *) "dc", NULL
23950 };
23951
23952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23953 if (obj0) {
23954 ecode1 = SWIG_AsVal_int(obj0, &val1);
23955 if (!SWIG_IsOK(ecode1)) {
23956 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
23957 }
23958 arg1 = static_cast< int >(val1);
23959 }
23960 if (obj1) {
23961 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
23962 if (!SWIG_IsOK(res2)) {
23963 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
23964 }
23965 arg2 = reinterpret_cast< wxDC * >(argp2);
23966 }
23967 {
23968 PyThreadState* __tstate = wxPyBeginAllowThreads();
23969 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
23970 wxPyEndAllowThreads(__tstate);
23971 if (PyErr_Occurred()) SWIG_fail;
23972 }
23973 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
23974 return resultobj;
23975 fail:
23976 return NULL;
23977 }
23978
23979
23980 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23981 PyObject *resultobj = 0;
23982 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
23983 wxDC *result = 0 ;
23984 void *argp1 = 0 ;
23985 int res1 = 0 ;
23986 PyObject *swig_obj[1] ;
23987
23988 if (!args) SWIG_fail;
23989 swig_obj[0] = args;
23990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
23991 if (!SWIG_IsOK(res1)) {
23992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
23993 }
23994 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
23995 {
23996 PyThreadState* __tstate = wxPyBeginAllowThreads();
23997 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
23998 wxPyEndAllowThreads(__tstate);
23999 if (PyErr_Occurred()) SWIG_fail;
24000 }
24001 {
24002 resultobj = wxPyMake_wxObject(result, (bool)0);
24003 }
24004 return resultobj;
24005 fail:
24006 return NULL;
24007 }
24008
24009
24010 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24011 PyObject *obj;
24012 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24013 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
24014 return SWIG_Py_Void();
24015 }
24016
24017 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24018 return SWIG_Python_InitShadowInstance(args);
24019 }
24020
24021 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24022 PyObject *resultobj = 0;
24023 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24024 int arg2 = (int) 0 ;
24025 wxFocusEvent *result = 0 ;
24026 int val1 ;
24027 int ecode1 = 0 ;
24028 int val2 ;
24029 int ecode2 = 0 ;
24030 PyObject * obj0 = 0 ;
24031 PyObject * obj1 = 0 ;
24032 char * kwnames[] = {
24033 (char *) "type",(char *) "winid", NULL
24034 };
24035
24036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24037 if (obj0) {
24038 ecode1 = SWIG_AsVal_int(obj0, &val1);
24039 if (!SWIG_IsOK(ecode1)) {
24040 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24041 }
24042 arg1 = static_cast< wxEventType >(val1);
24043 }
24044 if (obj1) {
24045 ecode2 = SWIG_AsVal_int(obj1, &val2);
24046 if (!SWIG_IsOK(ecode2)) {
24047 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
24048 }
24049 arg2 = static_cast< int >(val2);
24050 }
24051 {
24052 PyThreadState* __tstate = wxPyBeginAllowThreads();
24053 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
24054 wxPyEndAllowThreads(__tstate);
24055 if (PyErr_Occurred()) SWIG_fail;
24056 }
24057 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
24058 return resultobj;
24059 fail:
24060 return NULL;
24061 }
24062
24063
24064 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24065 PyObject *resultobj = 0;
24066 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
24067 wxWindow *result = 0 ;
24068 void *argp1 = 0 ;
24069 int res1 = 0 ;
24070 PyObject *swig_obj[1] ;
24071
24072 if (!args) SWIG_fail;
24073 swig_obj[0] = args;
24074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
24075 if (!SWIG_IsOK(res1)) {
24076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
24077 }
24078 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
24079 {
24080 PyThreadState* __tstate = wxPyBeginAllowThreads();
24081 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
24082 wxPyEndAllowThreads(__tstate);
24083 if (PyErr_Occurred()) SWIG_fail;
24084 }
24085 {
24086 resultobj = wxPyMake_wxObject(result, (bool)0);
24087 }
24088 return resultobj;
24089 fail:
24090 return NULL;
24091 }
24092
24093
24094 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24095 PyObject *resultobj = 0;
24096 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
24097 wxWindow *arg2 = (wxWindow *) 0 ;
24098 void *argp1 = 0 ;
24099 int res1 = 0 ;
24100 void *argp2 = 0 ;
24101 int res2 = 0 ;
24102 PyObject * obj0 = 0 ;
24103 PyObject * obj1 = 0 ;
24104 char * kwnames[] = {
24105 (char *) "self",(char *) "win", NULL
24106 };
24107
24108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
24109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
24110 if (!SWIG_IsOK(res1)) {
24111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
24112 }
24113 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
24114 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
24115 if (!SWIG_IsOK(res2)) {
24116 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
24117 }
24118 arg2 = reinterpret_cast< wxWindow * >(argp2);
24119 {
24120 PyThreadState* __tstate = wxPyBeginAllowThreads();
24121 (arg1)->SetWindow(arg2);
24122 wxPyEndAllowThreads(__tstate);
24123 if (PyErr_Occurred()) SWIG_fail;
24124 }
24125 resultobj = SWIG_Py_Void();
24126 return resultobj;
24127 fail:
24128 return NULL;
24129 }
24130
24131
24132 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24133 PyObject *obj;
24134 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24135 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
24136 return SWIG_Py_Void();
24137 }
24138
24139 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24140 return SWIG_Python_InitShadowInstance(args);
24141 }
24142
24143 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24144 PyObject *resultobj = 0;
24145 wxWindow *arg1 = (wxWindow *) NULL ;
24146 wxChildFocusEvent *result = 0 ;
24147 void *argp1 = 0 ;
24148 int res1 = 0 ;
24149 PyObject * obj0 = 0 ;
24150 char * kwnames[] = {
24151 (char *) "win", NULL
24152 };
24153
24154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
24155 if (obj0) {
24156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
24157 if (!SWIG_IsOK(res1)) {
24158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
24159 }
24160 arg1 = reinterpret_cast< wxWindow * >(argp1);
24161 }
24162 {
24163 PyThreadState* __tstate = wxPyBeginAllowThreads();
24164 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
24165 wxPyEndAllowThreads(__tstate);
24166 if (PyErr_Occurred()) SWIG_fail;
24167 }
24168 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
24169 return resultobj;
24170 fail:
24171 return NULL;
24172 }
24173
24174
24175 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24176 PyObject *resultobj = 0;
24177 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
24178 wxWindow *result = 0 ;
24179 void *argp1 = 0 ;
24180 int res1 = 0 ;
24181 PyObject *swig_obj[1] ;
24182
24183 if (!args) SWIG_fail;
24184 swig_obj[0] = args;
24185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
24186 if (!SWIG_IsOK(res1)) {
24187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
24188 }
24189 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
24190 {
24191 PyThreadState* __tstate = wxPyBeginAllowThreads();
24192 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
24193 wxPyEndAllowThreads(__tstate);
24194 if (PyErr_Occurred()) SWIG_fail;
24195 }
24196 {
24197 resultobj = wxPyMake_wxObject(result, (bool)0);
24198 }
24199 return resultobj;
24200 fail:
24201 return NULL;
24202 }
24203
24204
24205 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24206 PyObject *obj;
24207 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24208 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
24209 return SWIG_Py_Void();
24210 }
24211
24212 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24213 return SWIG_Python_InitShadowInstance(args);
24214 }
24215
24216 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24217 PyObject *resultobj = 0;
24218 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24219 bool arg2 = (bool) true ;
24220 int arg3 = (int) 0 ;
24221 wxActivateEvent *result = 0 ;
24222 int val1 ;
24223 int ecode1 = 0 ;
24224 bool val2 ;
24225 int ecode2 = 0 ;
24226 int val3 ;
24227 int ecode3 = 0 ;
24228 PyObject * obj0 = 0 ;
24229 PyObject * obj1 = 0 ;
24230 PyObject * obj2 = 0 ;
24231 char * kwnames[] = {
24232 (char *) "type",(char *) "active",(char *) "Id", NULL
24233 };
24234
24235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24236 if (obj0) {
24237 ecode1 = SWIG_AsVal_int(obj0, &val1);
24238 if (!SWIG_IsOK(ecode1)) {
24239 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24240 }
24241 arg1 = static_cast< wxEventType >(val1);
24242 }
24243 if (obj1) {
24244 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24245 if (!SWIG_IsOK(ecode2)) {
24246 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
24247 }
24248 arg2 = static_cast< bool >(val2);
24249 }
24250 if (obj2) {
24251 ecode3 = SWIG_AsVal_int(obj2, &val3);
24252 if (!SWIG_IsOK(ecode3)) {
24253 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
24254 }
24255 arg3 = static_cast< int >(val3);
24256 }
24257 {
24258 PyThreadState* __tstate = wxPyBeginAllowThreads();
24259 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
24260 wxPyEndAllowThreads(__tstate);
24261 if (PyErr_Occurred()) SWIG_fail;
24262 }
24263 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
24264 return resultobj;
24265 fail:
24266 return NULL;
24267 }
24268
24269
24270 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24271 PyObject *resultobj = 0;
24272 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
24273 bool result;
24274 void *argp1 = 0 ;
24275 int res1 = 0 ;
24276 PyObject *swig_obj[1] ;
24277
24278 if (!args) SWIG_fail;
24279 swig_obj[0] = args;
24280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
24281 if (!SWIG_IsOK(res1)) {
24282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
24283 }
24284 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
24285 {
24286 PyThreadState* __tstate = wxPyBeginAllowThreads();
24287 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
24288 wxPyEndAllowThreads(__tstate);
24289 if (PyErr_Occurred()) SWIG_fail;
24290 }
24291 {
24292 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24293 }
24294 return resultobj;
24295 fail:
24296 return NULL;
24297 }
24298
24299
24300 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24301 PyObject *obj;
24302 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24303 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
24304 return SWIG_Py_Void();
24305 }
24306
24307 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24308 return SWIG_Python_InitShadowInstance(args);
24309 }
24310
24311 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24312 PyObject *resultobj = 0;
24313 int arg1 = (int) 0 ;
24314 wxInitDialogEvent *result = 0 ;
24315 int val1 ;
24316 int ecode1 = 0 ;
24317 PyObject * obj0 = 0 ;
24318 char * kwnames[] = {
24319 (char *) "Id", NULL
24320 };
24321
24322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
24323 if (obj0) {
24324 ecode1 = SWIG_AsVal_int(obj0, &val1);
24325 if (!SWIG_IsOK(ecode1)) {
24326 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
24327 }
24328 arg1 = static_cast< int >(val1);
24329 }
24330 {
24331 PyThreadState* __tstate = wxPyBeginAllowThreads();
24332 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
24333 wxPyEndAllowThreads(__tstate);
24334 if (PyErr_Occurred()) SWIG_fail;
24335 }
24336 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
24337 return resultobj;
24338 fail:
24339 return NULL;
24340 }
24341
24342
24343 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24344 PyObject *obj;
24345 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24346 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
24347 return SWIG_Py_Void();
24348 }
24349
24350 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24351 return SWIG_Python_InitShadowInstance(args);
24352 }
24353
24354 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24355 PyObject *resultobj = 0;
24356 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24357 int arg2 = (int) 0 ;
24358 wxMenu *arg3 = (wxMenu *) NULL ;
24359 wxMenuEvent *result = 0 ;
24360 int val1 ;
24361 int ecode1 = 0 ;
24362 int val2 ;
24363 int ecode2 = 0 ;
24364 void *argp3 = 0 ;
24365 int res3 = 0 ;
24366 PyObject * obj0 = 0 ;
24367 PyObject * obj1 = 0 ;
24368 PyObject * obj2 = 0 ;
24369 char * kwnames[] = {
24370 (char *) "type",(char *) "winid",(char *) "menu", NULL
24371 };
24372
24373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24374 if (obj0) {
24375 ecode1 = SWIG_AsVal_int(obj0, &val1);
24376 if (!SWIG_IsOK(ecode1)) {
24377 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24378 }
24379 arg1 = static_cast< wxEventType >(val1);
24380 }
24381 if (obj1) {
24382 ecode2 = SWIG_AsVal_int(obj1, &val2);
24383 if (!SWIG_IsOK(ecode2)) {
24384 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
24385 }
24386 arg2 = static_cast< int >(val2);
24387 }
24388 if (obj2) {
24389 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
24390 if (!SWIG_IsOK(res3)) {
24391 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
24392 }
24393 arg3 = reinterpret_cast< wxMenu * >(argp3);
24394 }
24395 {
24396 PyThreadState* __tstate = wxPyBeginAllowThreads();
24397 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
24398 wxPyEndAllowThreads(__tstate);
24399 if (PyErr_Occurred()) SWIG_fail;
24400 }
24401 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
24402 return resultobj;
24403 fail:
24404 return NULL;
24405 }
24406
24407
24408 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24409 PyObject *resultobj = 0;
24410 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24411 int 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_wxMenuEvent, 0 | 0 );
24419 if (!SWIG_IsOK(res1)) {
24420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24421 }
24422 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24423 {
24424 PyThreadState* __tstate = wxPyBeginAllowThreads();
24425 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
24426 wxPyEndAllowThreads(__tstate);
24427 if (PyErr_Occurred()) SWIG_fail;
24428 }
24429 resultobj = SWIG_From_int(static_cast< int >(result));
24430 return resultobj;
24431 fail:
24432 return NULL;
24433 }
24434
24435
24436 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24437 PyObject *resultobj = 0;
24438 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24439 bool result;
24440 void *argp1 = 0 ;
24441 int res1 = 0 ;
24442 PyObject *swig_obj[1] ;
24443
24444 if (!args) SWIG_fail;
24445 swig_obj[0] = args;
24446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24447 if (!SWIG_IsOK(res1)) {
24448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24449 }
24450 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24451 {
24452 PyThreadState* __tstate = wxPyBeginAllowThreads();
24453 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
24454 wxPyEndAllowThreads(__tstate);
24455 if (PyErr_Occurred()) SWIG_fail;
24456 }
24457 {
24458 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24459 }
24460 return resultobj;
24461 fail:
24462 return NULL;
24463 }
24464
24465
24466 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24467 PyObject *resultobj = 0;
24468 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24469 wxMenu *result = 0 ;
24470 void *argp1 = 0 ;
24471 int res1 = 0 ;
24472 PyObject *swig_obj[1] ;
24473
24474 if (!args) SWIG_fail;
24475 swig_obj[0] = args;
24476 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24477 if (!SWIG_IsOK(res1)) {
24478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24479 }
24480 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24481 {
24482 PyThreadState* __tstate = wxPyBeginAllowThreads();
24483 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
24484 wxPyEndAllowThreads(__tstate);
24485 if (PyErr_Occurred()) SWIG_fail;
24486 }
24487 {
24488 resultobj = wxPyMake_wxObject(result, (bool)0);
24489 }
24490 return resultobj;
24491 fail:
24492 return NULL;
24493 }
24494
24495
24496 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24497 PyObject *obj;
24498 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24499 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24500 return SWIG_Py_Void();
24501 }
24502
24503 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24504 return SWIG_Python_InitShadowInstance(args);
24505 }
24506
24507 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24508 PyObject *resultobj = 0;
24509 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24510 int arg2 = (int) 0 ;
24511 wxCloseEvent *result = 0 ;
24512 int val1 ;
24513 int ecode1 = 0 ;
24514 int val2 ;
24515 int ecode2 = 0 ;
24516 PyObject * obj0 = 0 ;
24517 PyObject * obj1 = 0 ;
24518 char * kwnames[] = {
24519 (char *) "type",(char *) "winid", NULL
24520 };
24521
24522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24523 if (obj0) {
24524 ecode1 = SWIG_AsVal_int(obj0, &val1);
24525 if (!SWIG_IsOK(ecode1)) {
24526 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24527 }
24528 arg1 = static_cast< wxEventType >(val1);
24529 }
24530 if (obj1) {
24531 ecode2 = SWIG_AsVal_int(obj1, &val2);
24532 if (!SWIG_IsOK(ecode2)) {
24533 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24534 }
24535 arg2 = static_cast< int >(val2);
24536 }
24537 {
24538 PyThreadState* __tstate = wxPyBeginAllowThreads();
24539 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
24540 wxPyEndAllowThreads(__tstate);
24541 if (PyErr_Occurred()) SWIG_fail;
24542 }
24543 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
24544 return resultobj;
24545 fail:
24546 return NULL;
24547 }
24548
24549
24550 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24551 PyObject *resultobj = 0;
24552 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24553 bool arg2 ;
24554 void *argp1 = 0 ;
24555 int res1 = 0 ;
24556 bool val2 ;
24557 int ecode2 = 0 ;
24558 PyObject * obj0 = 0 ;
24559 PyObject * obj1 = 0 ;
24560 char * kwnames[] = {
24561 (char *) "self",(char *) "logOff", NULL
24562 };
24563
24564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
24565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24566 if (!SWIG_IsOK(res1)) {
24567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24568 }
24569 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24570 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24571 if (!SWIG_IsOK(ecode2)) {
24572 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24573 }
24574 arg2 = static_cast< bool >(val2);
24575 {
24576 PyThreadState* __tstate = wxPyBeginAllowThreads();
24577 (arg1)->SetLoggingOff(arg2);
24578 wxPyEndAllowThreads(__tstate);
24579 if (PyErr_Occurred()) SWIG_fail;
24580 }
24581 resultobj = SWIG_Py_Void();
24582 return resultobj;
24583 fail:
24584 return NULL;
24585 }
24586
24587
24588 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24589 PyObject *resultobj = 0;
24590 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24591 bool result;
24592 void *argp1 = 0 ;
24593 int res1 = 0 ;
24594 PyObject *swig_obj[1] ;
24595
24596 if (!args) SWIG_fail;
24597 swig_obj[0] = args;
24598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24599 if (!SWIG_IsOK(res1)) {
24600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24601 }
24602 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24603 {
24604 PyThreadState* __tstate = wxPyBeginAllowThreads();
24605 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24606 wxPyEndAllowThreads(__tstate);
24607 if (PyErr_Occurred()) SWIG_fail;
24608 }
24609 {
24610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24611 }
24612 return resultobj;
24613 fail:
24614 return NULL;
24615 }
24616
24617
24618 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24619 PyObject *resultobj = 0;
24620 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24621 bool arg2 = (bool) true ;
24622 void *argp1 = 0 ;
24623 int res1 = 0 ;
24624 bool val2 ;
24625 int ecode2 = 0 ;
24626 PyObject * obj0 = 0 ;
24627 PyObject * obj1 = 0 ;
24628 char * kwnames[] = {
24629 (char *) "self",(char *) "veto", NULL
24630 };
24631
24632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24634 if (!SWIG_IsOK(res1)) {
24635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24636 }
24637 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24638 if (obj1) {
24639 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24640 if (!SWIG_IsOK(ecode2)) {
24641 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24642 }
24643 arg2 = static_cast< bool >(val2);
24644 }
24645 {
24646 PyThreadState* __tstate = wxPyBeginAllowThreads();
24647 (arg1)->Veto(arg2);
24648 wxPyEndAllowThreads(__tstate);
24649 if (PyErr_Occurred()) SWIG_fail;
24650 }
24651 resultobj = SWIG_Py_Void();
24652 return resultobj;
24653 fail:
24654 return NULL;
24655 }
24656
24657
24658 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24659 PyObject *resultobj = 0;
24660 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24661 bool result;
24662 void *argp1 = 0 ;
24663 int res1 = 0 ;
24664 PyObject *swig_obj[1] ;
24665
24666 if (!args) SWIG_fail;
24667 swig_obj[0] = args;
24668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24669 if (!SWIG_IsOK(res1)) {
24670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24671 }
24672 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24673 {
24674 PyThreadState* __tstate = wxPyBeginAllowThreads();
24675 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24676 wxPyEndAllowThreads(__tstate);
24677 if (PyErr_Occurred()) SWIG_fail;
24678 }
24679 {
24680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24681 }
24682 return resultobj;
24683 fail:
24684 return NULL;
24685 }
24686
24687
24688 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24689 PyObject *resultobj = 0;
24690 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24691 bool arg2 ;
24692 void *argp1 = 0 ;
24693 int res1 = 0 ;
24694 bool val2 ;
24695 int ecode2 = 0 ;
24696 PyObject * obj0 = 0 ;
24697 PyObject * obj1 = 0 ;
24698 char * kwnames[] = {
24699 (char *) "self",(char *) "canVeto", NULL
24700 };
24701
24702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
24703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24704 if (!SWIG_IsOK(res1)) {
24705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24706 }
24707 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24708 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24709 if (!SWIG_IsOK(ecode2)) {
24710 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
24711 }
24712 arg2 = static_cast< bool >(val2);
24713 {
24714 PyThreadState* __tstate = wxPyBeginAllowThreads();
24715 (arg1)->SetCanVeto(arg2);
24716 wxPyEndAllowThreads(__tstate);
24717 if (PyErr_Occurred()) SWIG_fail;
24718 }
24719 resultobj = SWIG_Py_Void();
24720 return resultobj;
24721 fail:
24722 return NULL;
24723 }
24724
24725
24726 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24727 PyObject *resultobj = 0;
24728 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24729 bool result;
24730 void *argp1 = 0 ;
24731 int res1 = 0 ;
24732 PyObject *swig_obj[1] ;
24733
24734 if (!args) SWIG_fail;
24735 swig_obj[0] = args;
24736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24737 if (!SWIG_IsOK(res1)) {
24738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24739 }
24740 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24741 {
24742 PyThreadState* __tstate = wxPyBeginAllowThreads();
24743 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
24744 wxPyEndAllowThreads(__tstate);
24745 if (PyErr_Occurred()) SWIG_fail;
24746 }
24747 {
24748 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24749 }
24750 return resultobj;
24751 fail:
24752 return NULL;
24753 }
24754
24755
24756 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24757 PyObject *obj;
24758 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24759 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
24760 return SWIG_Py_Void();
24761 }
24762
24763 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24764 return SWIG_Python_InitShadowInstance(args);
24765 }
24766
24767 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24768 PyObject *resultobj = 0;
24769 int arg1 = (int) 0 ;
24770 bool arg2 = (bool) false ;
24771 wxShowEvent *result = 0 ;
24772 int val1 ;
24773 int ecode1 = 0 ;
24774 bool val2 ;
24775 int ecode2 = 0 ;
24776 PyObject * obj0 = 0 ;
24777 PyObject * obj1 = 0 ;
24778 char * kwnames[] = {
24779 (char *) "winid",(char *) "show", NULL
24780 };
24781
24782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24783 if (obj0) {
24784 ecode1 = SWIG_AsVal_int(obj0, &val1);
24785 if (!SWIG_IsOK(ecode1)) {
24786 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
24787 }
24788 arg1 = static_cast< int >(val1);
24789 }
24790 if (obj1) {
24791 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24792 if (!SWIG_IsOK(ecode2)) {
24793 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
24794 }
24795 arg2 = static_cast< bool >(val2);
24796 }
24797 {
24798 PyThreadState* __tstate = wxPyBeginAllowThreads();
24799 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
24800 wxPyEndAllowThreads(__tstate);
24801 if (PyErr_Occurred()) SWIG_fail;
24802 }
24803 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
24804 return resultobj;
24805 fail:
24806 return NULL;
24807 }
24808
24809
24810 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24811 PyObject *resultobj = 0;
24812 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24813 bool arg2 ;
24814 void *argp1 = 0 ;
24815 int res1 = 0 ;
24816 bool val2 ;
24817 int ecode2 = 0 ;
24818 PyObject * obj0 = 0 ;
24819 PyObject * obj1 = 0 ;
24820 char * kwnames[] = {
24821 (char *) "self",(char *) "show", NULL
24822 };
24823
24824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
24825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24826 if (!SWIG_IsOK(res1)) {
24827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
24828 }
24829 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24830 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24831 if (!SWIG_IsOK(ecode2)) {
24832 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
24833 }
24834 arg2 = static_cast< bool >(val2);
24835 {
24836 PyThreadState* __tstate = wxPyBeginAllowThreads();
24837 (arg1)->SetShow(arg2);
24838 wxPyEndAllowThreads(__tstate);
24839 if (PyErr_Occurred()) SWIG_fail;
24840 }
24841 resultobj = SWIG_Py_Void();
24842 return resultobj;
24843 fail:
24844 return NULL;
24845 }
24846
24847
24848 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24849 PyObject *resultobj = 0;
24850 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24851 bool result;
24852 void *argp1 = 0 ;
24853 int res1 = 0 ;
24854 PyObject *swig_obj[1] ;
24855
24856 if (!args) SWIG_fail;
24857 swig_obj[0] = args;
24858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24859 if (!SWIG_IsOK(res1)) {
24860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
24861 }
24862 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24863 {
24864 PyThreadState* __tstate = wxPyBeginAllowThreads();
24865 result = (bool)((wxShowEvent const *)arg1)->GetShow();
24866 wxPyEndAllowThreads(__tstate);
24867 if (PyErr_Occurred()) SWIG_fail;
24868 }
24869 {
24870 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24871 }
24872 return resultobj;
24873 fail:
24874 return NULL;
24875 }
24876
24877
24878 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24879 PyObject *obj;
24880 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24881 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
24882 return SWIG_Py_Void();
24883 }
24884
24885 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24886 return SWIG_Python_InitShadowInstance(args);
24887 }
24888
24889 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24890 PyObject *resultobj = 0;
24891 int arg1 = (int) 0 ;
24892 bool arg2 = (bool) true ;
24893 wxIconizeEvent *result = 0 ;
24894 int val1 ;
24895 int ecode1 = 0 ;
24896 bool val2 ;
24897 int ecode2 = 0 ;
24898 PyObject * obj0 = 0 ;
24899 PyObject * obj1 = 0 ;
24900 char * kwnames[] = {
24901 (char *) "id",(char *) "iconized", NULL
24902 };
24903
24904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24905 if (obj0) {
24906 ecode1 = SWIG_AsVal_int(obj0, &val1);
24907 if (!SWIG_IsOK(ecode1)) {
24908 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
24909 }
24910 arg1 = static_cast< int >(val1);
24911 }
24912 if (obj1) {
24913 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24914 if (!SWIG_IsOK(ecode2)) {
24915 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
24916 }
24917 arg2 = static_cast< bool >(val2);
24918 }
24919 {
24920 PyThreadState* __tstate = wxPyBeginAllowThreads();
24921 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
24922 wxPyEndAllowThreads(__tstate);
24923 if (PyErr_Occurred()) SWIG_fail;
24924 }
24925 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
24926 return resultobj;
24927 fail:
24928 return NULL;
24929 }
24930
24931
24932 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24933 PyObject *resultobj = 0;
24934 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
24935 bool result;
24936 void *argp1 = 0 ;
24937 int res1 = 0 ;
24938 PyObject *swig_obj[1] ;
24939
24940 if (!args) SWIG_fail;
24941 swig_obj[0] = args;
24942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
24943 if (!SWIG_IsOK(res1)) {
24944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
24945 }
24946 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
24947 {
24948 PyThreadState* __tstate = wxPyBeginAllowThreads();
24949 result = (bool)(arg1)->Iconized();
24950 wxPyEndAllowThreads(__tstate);
24951 if (PyErr_Occurred()) SWIG_fail;
24952 }
24953 {
24954 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24955 }
24956 return resultobj;
24957 fail:
24958 return NULL;
24959 }
24960
24961
24962 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24963 PyObject *obj;
24964 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24965 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
24966 return SWIG_Py_Void();
24967 }
24968
24969 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24970 return SWIG_Python_InitShadowInstance(args);
24971 }
24972
24973 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24974 PyObject *resultobj = 0;
24975 int arg1 = (int) 0 ;
24976 wxMaximizeEvent *result = 0 ;
24977 int val1 ;
24978 int ecode1 = 0 ;
24979 PyObject * obj0 = 0 ;
24980 char * kwnames[] = {
24981 (char *) "id", NULL
24982 };
24983
24984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
24985 if (obj0) {
24986 ecode1 = SWIG_AsVal_int(obj0, &val1);
24987 if (!SWIG_IsOK(ecode1)) {
24988 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
24989 }
24990 arg1 = static_cast< int >(val1);
24991 }
24992 {
24993 PyThreadState* __tstate = wxPyBeginAllowThreads();
24994 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
24995 wxPyEndAllowThreads(__tstate);
24996 if (PyErr_Occurred()) SWIG_fail;
24997 }
24998 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
24999 return resultobj;
25000 fail:
25001 return NULL;
25002 }
25003
25004
25005 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25006 PyObject *obj;
25007 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25008 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
25009 return SWIG_Py_Void();
25010 }
25011
25012 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25013 return SWIG_Python_InitShadowInstance(args);
25014 }
25015
25016 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25017 PyObject *resultobj = 0;
25018 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
25019 wxPoint result;
25020 void *argp1 = 0 ;
25021 int res1 = 0 ;
25022 PyObject *swig_obj[1] ;
25023
25024 if (!args) SWIG_fail;
25025 swig_obj[0] = args;
25026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
25027 if (!SWIG_IsOK(res1)) {
25028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
25029 }
25030 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
25031 {
25032 PyThreadState* __tstate = wxPyBeginAllowThreads();
25033 result = (arg1)->GetPosition();
25034 wxPyEndAllowThreads(__tstate);
25035 if (PyErr_Occurred()) SWIG_fail;
25036 }
25037 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
25038 return resultobj;
25039 fail:
25040 return NULL;
25041 }
25042
25043
25044 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25045 PyObject *resultobj = 0;
25046 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
25047 int result;
25048 void *argp1 = 0 ;
25049 int res1 = 0 ;
25050 PyObject *swig_obj[1] ;
25051
25052 if (!args) SWIG_fail;
25053 swig_obj[0] = args;
25054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
25055 if (!SWIG_IsOK(res1)) {
25056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
25057 }
25058 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
25059 {
25060 PyThreadState* __tstate = wxPyBeginAllowThreads();
25061 result = (int)(arg1)->GetNumberOfFiles();
25062 wxPyEndAllowThreads(__tstate);
25063 if (PyErr_Occurred()) SWIG_fail;
25064 }
25065 resultobj = SWIG_From_int(static_cast< int >(result));
25066 return resultobj;
25067 fail:
25068 return NULL;
25069 }
25070
25071
25072 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25073 PyObject *resultobj = 0;
25074 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
25075 PyObject *result = 0 ;
25076 void *argp1 = 0 ;
25077 int res1 = 0 ;
25078 PyObject *swig_obj[1] ;
25079
25080 if (!args) SWIG_fail;
25081 swig_obj[0] = args;
25082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
25083 if (!SWIG_IsOK(res1)) {
25084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
25085 }
25086 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
25087 {
25088 PyThreadState* __tstate = wxPyBeginAllowThreads();
25089 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
25090 wxPyEndAllowThreads(__tstate);
25091 if (PyErr_Occurred()) SWIG_fail;
25092 }
25093 resultobj = result;
25094 return resultobj;
25095 fail:
25096 return NULL;
25097 }
25098
25099
25100 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25101 PyObject *obj;
25102 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25103 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
25104 return SWIG_Py_Void();
25105 }
25106
25107 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25108 PyObject *resultobj = 0;
25109 int arg1 = (int) 0 ;
25110 wxUpdateUIEvent *result = 0 ;
25111 int val1 ;
25112 int ecode1 = 0 ;
25113 PyObject * obj0 = 0 ;
25114 char * kwnames[] = {
25115 (char *) "commandId", NULL
25116 };
25117
25118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
25119 if (obj0) {
25120 ecode1 = SWIG_AsVal_int(obj0, &val1);
25121 if (!SWIG_IsOK(ecode1)) {
25122 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
25123 }
25124 arg1 = static_cast< int >(val1);
25125 }
25126 {
25127 PyThreadState* __tstate = wxPyBeginAllowThreads();
25128 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
25129 wxPyEndAllowThreads(__tstate);
25130 if (PyErr_Occurred()) SWIG_fail;
25131 }
25132 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
25133 return resultobj;
25134 fail:
25135 return NULL;
25136 }
25137
25138
25139 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25140 PyObject *resultobj = 0;
25141 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25142 bool result;
25143 void *argp1 = 0 ;
25144 int res1 = 0 ;
25145 PyObject *swig_obj[1] ;
25146
25147 if (!args) SWIG_fail;
25148 swig_obj[0] = args;
25149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25150 if (!SWIG_IsOK(res1)) {
25151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25152 }
25153 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25154 {
25155 PyThreadState* __tstate = wxPyBeginAllowThreads();
25156 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
25157 wxPyEndAllowThreads(__tstate);
25158 if (PyErr_Occurred()) SWIG_fail;
25159 }
25160 {
25161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25162 }
25163 return resultobj;
25164 fail:
25165 return NULL;
25166 }
25167
25168
25169 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25170 PyObject *resultobj = 0;
25171 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25172 bool result;
25173 void *argp1 = 0 ;
25174 int res1 = 0 ;
25175 PyObject *swig_obj[1] ;
25176
25177 if (!args) SWIG_fail;
25178 swig_obj[0] = args;
25179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25180 if (!SWIG_IsOK(res1)) {
25181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25182 }
25183 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25184 {
25185 PyThreadState* __tstate = wxPyBeginAllowThreads();
25186 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
25187 wxPyEndAllowThreads(__tstate);
25188 if (PyErr_Occurred()) SWIG_fail;
25189 }
25190 {
25191 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25192 }
25193 return resultobj;
25194 fail:
25195 return NULL;
25196 }
25197
25198
25199 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25200 PyObject *resultobj = 0;
25201 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25202 bool result;
25203 void *argp1 = 0 ;
25204 int res1 = 0 ;
25205 PyObject *swig_obj[1] ;
25206
25207 if (!args) SWIG_fail;
25208 swig_obj[0] = args;
25209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25210 if (!SWIG_IsOK(res1)) {
25211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25212 }
25213 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25214 {
25215 PyThreadState* __tstate = wxPyBeginAllowThreads();
25216 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
25217 wxPyEndAllowThreads(__tstate);
25218 if (PyErr_Occurred()) SWIG_fail;
25219 }
25220 {
25221 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25222 }
25223 return resultobj;
25224 fail:
25225 return NULL;
25226 }
25227
25228
25229 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25230 PyObject *resultobj = 0;
25231 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25232 wxString result;
25233 void *argp1 = 0 ;
25234 int res1 = 0 ;
25235 PyObject *swig_obj[1] ;
25236
25237 if (!args) SWIG_fail;
25238 swig_obj[0] = args;
25239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25240 if (!SWIG_IsOK(res1)) {
25241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25242 }
25243 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25244 {
25245 PyThreadState* __tstate = wxPyBeginAllowThreads();
25246 result = ((wxUpdateUIEvent const *)arg1)->GetText();
25247 wxPyEndAllowThreads(__tstate);
25248 if (PyErr_Occurred()) SWIG_fail;
25249 }
25250 {
25251 #if wxUSE_UNICODE
25252 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25253 #else
25254 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25255 #endif
25256 }
25257 return resultobj;
25258 fail:
25259 return NULL;
25260 }
25261
25262
25263 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25264 PyObject *resultobj = 0;
25265 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25266 bool result;
25267 void *argp1 = 0 ;
25268 int res1 = 0 ;
25269 PyObject *swig_obj[1] ;
25270
25271 if (!args) SWIG_fail;
25272 swig_obj[0] = args;
25273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25274 if (!SWIG_IsOK(res1)) {
25275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25276 }
25277 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25278 {
25279 PyThreadState* __tstate = wxPyBeginAllowThreads();
25280 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
25281 wxPyEndAllowThreads(__tstate);
25282 if (PyErr_Occurred()) SWIG_fail;
25283 }
25284 {
25285 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25286 }
25287 return resultobj;
25288 fail:
25289 return NULL;
25290 }
25291
25292
25293 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25294 PyObject *resultobj = 0;
25295 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25296 bool result;
25297 void *argp1 = 0 ;
25298 int res1 = 0 ;
25299 PyObject *swig_obj[1] ;
25300
25301 if (!args) SWIG_fail;
25302 swig_obj[0] = args;
25303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25304 if (!SWIG_IsOK(res1)) {
25305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25306 }
25307 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25308 {
25309 PyThreadState* __tstate = wxPyBeginAllowThreads();
25310 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
25311 wxPyEndAllowThreads(__tstate);
25312 if (PyErr_Occurred()) SWIG_fail;
25313 }
25314 {
25315 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25316 }
25317 return resultobj;
25318 fail:
25319 return NULL;
25320 }
25321
25322
25323 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25324 PyObject *resultobj = 0;
25325 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25326 bool result;
25327 void *argp1 = 0 ;
25328 int res1 = 0 ;
25329 PyObject *swig_obj[1] ;
25330
25331 if (!args) SWIG_fail;
25332 swig_obj[0] = args;
25333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25334 if (!SWIG_IsOK(res1)) {
25335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25336 }
25337 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25338 {
25339 PyThreadState* __tstate = wxPyBeginAllowThreads();
25340 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
25341 wxPyEndAllowThreads(__tstate);
25342 if (PyErr_Occurred()) SWIG_fail;
25343 }
25344 {
25345 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25346 }
25347 return resultobj;
25348 fail:
25349 return NULL;
25350 }
25351
25352
25353 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25354 PyObject *resultobj = 0;
25355 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25356 bool result;
25357 void *argp1 = 0 ;
25358 int res1 = 0 ;
25359 PyObject *swig_obj[1] ;
25360
25361 if (!args) SWIG_fail;
25362 swig_obj[0] = args;
25363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25364 if (!SWIG_IsOK(res1)) {
25365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25366 }
25367 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25368 {
25369 PyThreadState* __tstate = wxPyBeginAllowThreads();
25370 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
25371 wxPyEndAllowThreads(__tstate);
25372 if (PyErr_Occurred()) SWIG_fail;
25373 }
25374 {
25375 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25376 }
25377 return resultobj;
25378 fail:
25379 return NULL;
25380 }
25381
25382
25383 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25384 PyObject *resultobj = 0;
25385 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25386 bool arg2 ;
25387 void *argp1 = 0 ;
25388 int res1 = 0 ;
25389 bool val2 ;
25390 int ecode2 = 0 ;
25391 PyObject * obj0 = 0 ;
25392 PyObject * obj1 = 0 ;
25393 char * kwnames[] = {
25394 (char *) "self",(char *) "check", NULL
25395 };
25396
25397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
25398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25399 if (!SWIG_IsOK(res1)) {
25400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25401 }
25402 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25403 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25404 if (!SWIG_IsOK(ecode2)) {
25405 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
25406 }
25407 arg2 = static_cast< bool >(val2);
25408 {
25409 PyThreadState* __tstate = wxPyBeginAllowThreads();
25410 (arg1)->Check(arg2);
25411 wxPyEndAllowThreads(__tstate);
25412 if (PyErr_Occurred()) SWIG_fail;
25413 }
25414 resultobj = SWIG_Py_Void();
25415 return resultobj;
25416 fail:
25417 return NULL;
25418 }
25419
25420
25421 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25422 PyObject *resultobj = 0;
25423 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25424 bool arg2 ;
25425 void *argp1 = 0 ;
25426 int res1 = 0 ;
25427 bool val2 ;
25428 int ecode2 = 0 ;
25429 PyObject * obj0 = 0 ;
25430 PyObject * obj1 = 0 ;
25431 char * kwnames[] = {
25432 (char *) "self",(char *) "enable", NULL
25433 };
25434
25435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
25436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25437 if (!SWIG_IsOK(res1)) {
25438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25439 }
25440 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25441 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25442 if (!SWIG_IsOK(ecode2)) {
25443 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
25444 }
25445 arg2 = static_cast< bool >(val2);
25446 {
25447 PyThreadState* __tstate = wxPyBeginAllowThreads();
25448 (arg1)->Enable(arg2);
25449 wxPyEndAllowThreads(__tstate);
25450 if (PyErr_Occurred()) SWIG_fail;
25451 }
25452 resultobj = SWIG_Py_Void();
25453 return resultobj;
25454 fail:
25455 return NULL;
25456 }
25457
25458
25459 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25460 PyObject *resultobj = 0;
25461 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25462 bool arg2 ;
25463 void *argp1 = 0 ;
25464 int res1 = 0 ;
25465 bool val2 ;
25466 int ecode2 = 0 ;
25467 PyObject * obj0 = 0 ;
25468 PyObject * obj1 = 0 ;
25469 char * kwnames[] = {
25470 (char *) "self",(char *) "show", NULL
25471 };
25472
25473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
25474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25475 if (!SWIG_IsOK(res1)) {
25476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25477 }
25478 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25479 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25480 if (!SWIG_IsOK(ecode2)) {
25481 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
25482 }
25483 arg2 = static_cast< bool >(val2);
25484 {
25485 PyThreadState* __tstate = wxPyBeginAllowThreads();
25486 (arg1)->Show(arg2);
25487 wxPyEndAllowThreads(__tstate);
25488 if (PyErr_Occurred()) SWIG_fail;
25489 }
25490 resultobj = SWIG_Py_Void();
25491 return resultobj;
25492 fail:
25493 return NULL;
25494 }
25495
25496
25497 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25498 PyObject *resultobj = 0;
25499 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25500 wxString *arg2 = 0 ;
25501 void *argp1 = 0 ;
25502 int res1 = 0 ;
25503 bool temp2 = false ;
25504 PyObject * obj0 = 0 ;
25505 PyObject * obj1 = 0 ;
25506 char * kwnames[] = {
25507 (char *) "self",(char *) "text", NULL
25508 };
25509
25510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25512 if (!SWIG_IsOK(res1)) {
25513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25514 }
25515 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25516 {
25517 arg2 = wxString_in_helper(obj1);
25518 if (arg2 == NULL) SWIG_fail;
25519 temp2 = true;
25520 }
25521 {
25522 PyThreadState* __tstate = wxPyBeginAllowThreads();
25523 (arg1)->SetText((wxString const &)*arg2);
25524 wxPyEndAllowThreads(__tstate);
25525 if (PyErr_Occurred()) SWIG_fail;
25526 }
25527 resultobj = SWIG_Py_Void();
25528 {
25529 if (temp2)
25530 delete arg2;
25531 }
25532 return resultobj;
25533 fail:
25534 {
25535 if (temp2)
25536 delete arg2;
25537 }
25538 return NULL;
25539 }
25540
25541
25542 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25543 PyObject *resultobj = 0;
25544 long arg1 ;
25545 long val1 ;
25546 int ecode1 = 0 ;
25547 PyObject * obj0 = 0 ;
25548 char * kwnames[] = {
25549 (char *) "updateInterval", NULL
25550 };
25551
25552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
25553 ecode1 = SWIG_AsVal_long(obj0, &val1);
25554 if (!SWIG_IsOK(ecode1)) {
25555 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
25556 }
25557 arg1 = static_cast< long >(val1);
25558 {
25559 PyThreadState* __tstate = wxPyBeginAllowThreads();
25560 wxUpdateUIEvent::SetUpdateInterval(arg1);
25561 wxPyEndAllowThreads(__tstate);
25562 if (PyErr_Occurred()) SWIG_fail;
25563 }
25564 resultobj = SWIG_Py_Void();
25565 return resultobj;
25566 fail:
25567 return NULL;
25568 }
25569
25570
25571 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25572 PyObject *resultobj = 0;
25573 long result;
25574
25575 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25576 {
25577 PyThreadState* __tstate = wxPyBeginAllowThreads();
25578 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25579 wxPyEndAllowThreads(__tstate);
25580 if (PyErr_Occurred()) SWIG_fail;
25581 }
25582 resultobj = SWIG_From_long(static_cast< long >(result));
25583 return resultobj;
25584 fail:
25585 return NULL;
25586 }
25587
25588
25589 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25590 PyObject *resultobj = 0;
25591 wxWindow *arg1 = (wxWindow *) 0 ;
25592 bool result;
25593 void *argp1 = 0 ;
25594 int res1 = 0 ;
25595 PyObject * obj0 = 0 ;
25596 char * kwnames[] = {
25597 (char *) "win", NULL
25598 };
25599
25600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25602 if (!SWIG_IsOK(res1)) {
25603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25604 }
25605 arg1 = reinterpret_cast< wxWindow * >(argp1);
25606 {
25607 PyThreadState* __tstate = wxPyBeginAllowThreads();
25608 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25609 wxPyEndAllowThreads(__tstate);
25610 if (PyErr_Occurred()) SWIG_fail;
25611 }
25612 {
25613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25614 }
25615 return resultobj;
25616 fail:
25617 return NULL;
25618 }
25619
25620
25621 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25622 PyObject *resultobj = 0;
25623
25624 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25625 {
25626 PyThreadState* __tstate = wxPyBeginAllowThreads();
25627 wxUpdateUIEvent::ResetUpdateTime();
25628 wxPyEndAllowThreads(__tstate);
25629 if (PyErr_Occurred()) SWIG_fail;
25630 }
25631 resultobj = SWIG_Py_Void();
25632 return resultobj;
25633 fail:
25634 return NULL;
25635 }
25636
25637
25638 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25639 PyObject *resultobj = 0;
25640 wxUpdateUIMode arg1 ;
25641 int val1 ;
25642 int ecode1 = 0 ;
25643 PyObject * obj0 = 0 ;
25644 char * kwnames[] = {
25645 (char *) "mode", NULL
25646 };
25647
25648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25649 ecode1 = SWIG_AsVal_int(obj0, &val1);
25650 if (!SWIG_IsOK(ecode1)) {
25651 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25652 }
25653 arg1 = static_cast< wxUpdateUIMode >(val1);
25654 {
25655 PyThreadState* __tstate = wxPyBeginAllowThreads();
25656 wxUpdateUIEvent::SetMode(arg1);
25657 wxPyEndAllowThreads(__tstate);
25658 if (PyErr_Occurred()) SWIG_fail;
25659 }
25660 resultobj = SWIG_Py_Void();
25661 return resultobj;
25662 fail:
25663 return NULL;
25664 }
25665
25666
25667 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25668 PyObject *resultobj = 0;
25669 wxUpdateUIMode result;
25670
25671 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25672 {
25673 PyThreadState* __tstate = wxPyBeginAllowThreads();
25674 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25675 wxPyEndAllowThreads(__tstate);
25676 if (PyErr_Occurred()) SWIG_fail;
25677 }
25678 resultobj = SWIG_From_int(static_cast< int >(result));
25679 return resultobj;
25680 fail:
25681 return NULL;
25682 }
25683
25684
25685 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25686 PyObject *obj;
25687 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25688 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
25689 return SWIG_Py_Void();
25690 }
25691
25692 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25693 return SWIG_Python_InitShadowInstance(args);
25694 }
25695
25696 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25697 PyObject *resultobj = 0;
25698 wxSysColourChangedEvent *result = 0 ;
25699
25700 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
25701 {
25702 PyThreadState* __tstate = wxPyBeginAllowThreads();
25703 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
25704 wxPyEndAllowThreads(__tstate);
25705 if (PyErr_Occurred()) SWIG_fail;
25706 }
25707 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
25708 return resultobj;
25709 fail:
25710 return NULL;
25711 }
25712
25713
25714 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25715 PyObject *obj;
25716 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25717 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
25718 return SWIG_Py_Void();
25719 }
25720
25721 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25722 return SWIG_Python_InitShadowInstance(args);
25723 }
25724
25725 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25726 PyObject *resultobj = 0;
25727 int arg1 = (int) 0 ;
25728 wxWindow *arg2 = (wxWindow *) NULL ;
25729 wxMouseCaptureChangedEvent *result = 0 ;
25730 int val1 ;
25731 int ecode1 = 0 ;
25732 void *argp2 = 0 ;
25733 int res2 = 0 ;
25734 PyObject * obj0 = 0 ;
25735 PyObject * obj1 = 0 ;
25736 char * kwnames[] = {
25737 (char *) "winid",(char *) "gainedCapture", NULL
25738 };
25739
25740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25741 if (obj0) {
25742 ecode1 = SWIG_AsVal_int(obj0, &val1);
25743 if (!SWIG_IsOK(ecode1)) {
25744 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
25745 }
25746 arg1 = static_cast< int >(val1);
25747 }
25748 if (obj1) {
25749 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25750 if (!SWIG_IsOK(res2)) {
25751 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
25752 }
25753 arg2 = reinterpret_cast< wxWindow * >(argp2);
25754 }
25755 {
25756 PyThreadState* __tstate = wxPyBeginAllowThreads();
25757 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
25758 wxPyEndAllowThreads(__tstate);
25759 if (PyErr_Occurred()) SWIG_fail;
25760 }
25761 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
25762 return resultobj;
25763 fail:
25764 return NULL;
25765 }
25766
25767
25768 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25769 PyObject *resultobj = 0;
25770 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
25771 wxWindow *result = 0 ;
25772 void *argp1 = 0 ;
25773 int res1 = 0 ;
25774 PyObject *swig_obj[1] ;
25775
25776 if (!args) SWIG_fail;
25777 swig_obj[0] = args;
25778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
25779 if (!SWIG_IsOK(res1)) {
25780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
25781 }
25782 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
25783 {
25784 PyThreadState* __tstate = wxPyBeginAllowThreads();
25785 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
25786 wxPyEndAllowThreads(__tstate);
25787 if (PyErr_Occurred()) SWIG_fail;
25788 }
25789 {
25790 resultobj = wxPyMake_wxObject(result, (bool)0);
25791 }
25792 return resultobj;
25793 fail:
25794 return NULL;
25795 }
25796
25797
25798 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25799 PyObject *obj;
25800 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25801 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
25802 return SWIG_Py_Void();
25803 }
25804
25805 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25806 return SWIG_Python_InitShadowInstance(args);
25807 }
25808
25809 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25810 PyObject *resultobj = 0;
25811 int arg1 = (int) 0 ;
25812 wxMouseCaptureLostEvent *result = 0 ;
25813 int val1 ;
25814 int ecode1 = 0 ;
25815 PyObject * obj0 = 0 ;
25816 char * kwnames[] = {
25817 (char *) "winid", NULL
25818 };
25819
25820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
25821 if (obj0) {
25822 ecode1 = SWIG_AsVal_int(obj0, &val1);
25823 if (!SWIG_IsOK(ecode1)) {
25824 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
25825 }
25826 arg1 = static_cast< int >(val1);
25827 }
25828 {
25829 PyThreadState* __tstate = wxPyBeginAllowThreads();
25830 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
25831 wxPyEndAllowThreads(__tstate);
25832 if (PyErr_Occurred()) SWIG_fail;
25833 }
25834 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
25835 return resultobj;
25836 fail:
25837 return NULL;
25838 }
25839
25840
25841 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25842 PyObject *obj;
25843 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25844 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
25845 return SWIG_Py_Void();
25846 }
25847
25848 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25849 return SWIG_Python_InitShadowInstance(args);
25850 }
25851
25852 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25853 PyObject *resultobj = 0;
25854 wxDisplayChangedEvent *result = 0 ;
25855
25856 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
25857 {
25858 PyThreadState* __tstate = wxPyBeginAllowThreads();
25859 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
25860 wxPyEndAllowThreads(__tstate);
25861 if (PyErr_Occurred()) SWIG_fail;
25862 }
25863 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
25864 return resultobj;
25865 fail:
25866 return NULL;
25867 }
25868
25869
25870 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25871 PyObject *obj;
25872 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25873 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
25874 return SWIG_Py_Void();
25875 }
25876
25877 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25878 return SWIG_Python_InitShadowInstance(args);
25879 }
25880
25881 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25882 PyObject *resultobj = 0;
25883 int arg1 = (int) 0 ;
25884 wxPaletteChangedEvent *result = 0 ;
25885 int val1 ;
25886 int ecode1 = 0 ;
25887 PyObject * obj0 = 0 ;
25888 char * kwnames[] = {
25889 (char *) "id", NULL
25890 };
25891
25892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
25893 if (obj0) {
25894 ecode1 = SWIG_AsVal_int(obj0, &val1);
25895 if (!SWIG_IsOK(ecode1)) {
25896 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
25897 }
25898 arg1 = static_cast< int >(val1);
25899 }
25900 {
25901 PyThreadState* __tstate = wxPyBeginAllowThreads();
25902 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
25903 wxPyEndAllowThreads(__tstate);
25904 if (PyErr_Occurred()) SWIG_fail;
25905 }
25906 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
25907 return resultobj;
25908 fail:
25909 return NULL;
25910 }
25911
25912
25913 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25914 PyObject *resultobj = 0;
25915 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25916 wxWindow *arg2 = (wxWindow *) 0 ;
25917 void *argp1 = 0 ;
25918 int res1 = 0 ;
25919 void *argp2 = 0 ;
25920 int res2 = 0 ;
25921 PyObject * obj0 = 0 ;
25922 PyObject * obj1 = 0 ;
25923 char * kwnames[] = {
25924 (char *) "self",(char *) "win", NULL
25925 };
25926
25927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
25928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25929 if (!SWIG_IsOK(res1)) {
25930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25931 }
25932 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25933 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25934 if (!SWIG_IsOK(res2)) {
25935 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
25936 }
25937 arg2 = reinterpret_cast< wxWindow * >(argp2);
25938 {
25939 PyThreadState* __tstate = wxPyBeginAllowThreads();
25940 (arg1)->SetChangedWindow(arg2);
25941 wxPyEndAllowThreads(__tstate);
25942 if (PyErr_Occurred()) SWIG_fail;
25943 }
25944 resultobj = SWIG_Py_Void();
25945 return resultobj;
25946 fail:
25947 return NULL;
25948 }
25949
25950
25951 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25952 PyObject *resultobj = 0;
25953 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25954 wxWindow *result = 0 ;
25955 void *argp1 = 0 ;
25956 int res1 = 0 ;
25957 PyObject *swig_obj[1] ;
25958
25959 if (!args) SWIG_fail;
25960 swig_obj[0] = args;
25961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25962 if (!SWIG_IsOK(res1)) {
25963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25964 }
25965 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25966 {
25967 PyThreadState* __tstate = wxPyBeginAllowThreads();
25968 result = (wxWindow *)(arg1)->GetChangedWindow();
25969 wxPyEndAllowThreads(__tstate);
25970 if (PyErr_Occurred()) SWIG_fail;
25971 }
25972 {
25973 resultobj = wxPyMake_wxObject(result, (bool)0);
25974 }
25975 return resultobj;
25976 fail:
25977 return NULL;
25978 }
25979
25980
25981 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25982 PyObject *obj;
25983 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25984 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
25985 return SWIG_Py_Void();
25986 }
25987
25988 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25989 return SWIG_Python_InitShadowInstance(args);
25990 }
25991
25992 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25993 PyObject *resultobj = 0;
25994 int arg1 = (int) 0 ;
25995 wxQueryNewPaletteEvent *result = 0 ;
25996 int val1 ;
25997 int ecode1 = 0 ;
25998 PyObject * obj0 = 0 ;
25999 char * kwnames[] = {
26000 (char *) "winid", NULL
26001 };
26002
26003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
26004 if (obj0) {
26005 ecode1 = SWIG_AsVal_int(obj0, &val1);
26006 if (!SWIG_IsOK(ecode1)) {
26007 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
26008 }
26009 arg1 = static_cast< int >(val1);
26010 }
26011 {
26012 PyThreadState* __tstate = wxPyBeginAllowThreads();
26013 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
26014 wxPyEndAllowThreads(__tstate);
26015 if (PyErr_Occurred()) SWIG_fail;
26016 }
26017 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
26018 return resultobj;
26019 fail:
26020 return NULL;
26021 }
26022
26023
26024 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26025 PyObject *resultobj = 0;
26026 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
26027 bool arg2 ;
26028 void *argp1 = 0 ;
26029 int res1 = 0 ;
26030 bool val2 ;
26031 int ecode2 = 0 ;
26032 PyObject * obj0 = 0 ;
26033 PyObject * obj1 = 0 ;
26034 char * kwnames[] = {
26035 (char *) "self",(char *) "realized", NULL
26036 };
26037
26038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
26039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
26040 if (!SWIG_IsOK(res1)) {
26041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
26042 }
26043 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
26044 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26045 if (!SWIG_IsOK(ecode2)) {
26046 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
26047 }
26048 arg2 = static_cast< bool >(val2);
26049 {
26050 PyThreadState* __tstate = wxPyBeginAllowThreads();
26051 (arg1)->SetPaletteRealized(arg2);
26052 wxPyEndAllowThreads(__tstate);
26053 if (PyErr_Occurred()) SWIG_fail;
26054 }
26055 resultobj = SWIG_Py_Void();
26056 return resultobj;
26057 fail:
26058 return NULL;
26059 }
26060
26061
26062 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26063 PyObject *resultobj = 0;
26064 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
26065 bool result;
26066 void *argp1 = 0 ;
26067 int res1 = 0 ;
26068 PyObject *swig_obj[1] ;
26069
26070 if (!args) SWIG_fail;
26071 swig_obj[0] = args;
26072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
26073 if (!SWIG_IsOK(res1)) {
26074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
26075 }
26076 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
26077 {
26078 PyThreadState* __tstate = wxPyBeginAllowThreads();
26079 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
26080 wxPyEndAllowThreads(__tstate);
26081 if (PyErr_Occurred()) SWIG_fail;
26082 }
26083 {
26084 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26085 }
26086 return resultobj;
26087 fail:
26088 return NULL;
26089 }
26090
26091
26092 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26093 PyObject *obj;
26094 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26095 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
26096 return SWIG_Py_Void();
26097 }
26098
26099 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26100 return SWIG_Python_InitShadowInstance(args);
26101 }
26102
26103 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26104 PyObject *resultobj = 0;
26105 wxNavigationKeyEvent *result = 0 ;
26106
26107 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
26108 {
26109 PyThreadState* __tstate = wxPyBeginAllowThreads();
26110 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
26111 wxPyEndAllowThreads(__tstate);
26112 if (PyErr_Occurred()) SWIG_fail;
26113 }
26114 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
26115 return resultobj;
26116 fail:
26117 return NULL;
26118 }
26119
26120
26121 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26122 PyObject *resultobj = 0;
26123 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26124 bool result;
26125 void *argp1 = 0 ;
26126 int res1 = 0 ;
26127 PyObject *swig_obj[1] ;
26128
26129 if (!args) SWIG_fail;
26130 swig_obj[0] = args;
26131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26132 if (!SWIG_IsOK(res1)) {
26133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26134 }
26135 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26136 {
26137 PyThreadState* __tstate = wxPyBeginAllowThreads();
26138 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
26139 wxPyEndAllowThreads(__tstate);
26140 if (PyErr_Occurred()) SWIG_fail;
26141 }
26142 {
26143 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26144 }
26145 return resultobj;
26146 fail:
26147 return NULL;
26148 }
26149
26150
26151 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26152 PyObject *resultobj = 0;
26153 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26154 bool arg2 ;
26155 void *argp1 = 0 ;
26156 int res1 = 0 ;
26157 bool val2 ;
26158 int ecode2 = 0 ;
26159 PyObject * obj0 = 0 ;
26160 PyObject * obj1 = 0 ;
26161 char * kwnames[] = {
26162 (char *) "self",(char *) "forward", NULL
26163 };
26164
26165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
26166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26167 if (!SWIG_IsOK(res1)) {
26168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26169 }
26170 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26171 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26172 if (!SWIG_IsOK(ecode2)) {
26173 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
26174 }
26175 arg2 = static_cast< bool >(val2);
26176 {
26177 PyThreadState* __tstate = wxPyBeginAllowThreads();
26178 (arg1)->SetDirection(arg2);
26179 wxPyEndAllowThreads(__tstate);
26180 if (PyErr_Occurred()) SWIG_fail;
26181 }
26182 resultobj = SWIG_Py_Void();
26183 return resultobj;
26184 fail:
26185 return NULL;
26186 }
26187
26188
26189 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26190 PyObject *resultobj = 0;
26191 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26192 bool result;
26193 void *argp1 = 0 ;
26194 int res1 = 0 ;
26195 PyObject *swig_obj[1] ;
26196
26197 if (!args) SWIG_fail;
26198 swig_obj[0] = args;
26199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26200 if (!SWIG_IsOK(res1)) {
26201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26202 }
26203 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26204 {
26205 PyThreadState* __tstate = wxPyBeginAllowThreads();
26206 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
26207 wxPyEndAllowThreads(__tstate);
26208 if (PyErr_Occurred()) SWIG_fail;
26209 }
26210 {
26211 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26212 }
26213 return resultobj;
26214 fail:
26215 return NULL;
26216 }
26217
26218
26219 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26220 PyObject *resultobj = 0;
26221 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26222 bool arg2 ;
26223 void *argp1 = 0 ;
26224 int res1 = 0 ;
26225 bool val2 ;
26226 int ecode2 = 0 ;
26227 PyObject * obj0 = 0 ;
26228 PyObject * obj1 = 0 ;
26229 char * kwnames[] = {
26230 (char *) "self",(char *) "ischange", NULL
26231 };
26232
26233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
26234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26235 if (!SWIG_IsOK(res1)) {
26236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26237 }
26238 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26239 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26240 if (!SWIG_IsOK(ecode2)) {
26241 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
26242 }
26243 arg2 = static_cast< bool >(val2);
26244 {
26245 PyThreadState* __tstate = wxPyBeginAllowThreads();
26246 (arg1)->SetWindowChange(arg2);
26247 wxPyEndAllowThreads(__tstate);
26248 if (PyErr_Occurred()) SWIG_fail;
26249 }
26250 resultobj = SWIG_Py_Void();
26251 return resultobj;
26252 fail:
26253 return NULL;
26254 }
26255
26256
26257 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26258 PyObject *resultobj = 0;
26259 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26260 bool result;
26261 void *argp1 = 0 ;
26262 int res1 = 0 ;
26263 PyObject *swig_obj[1] ;
26264
26265 if (!args) SWIG_fail;
26266 swig_obj[0] = args;
26267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26268 if (!SWIG_IsOK(res1)) {
26269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26270 }
26271 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26272 {
26273 PyThreadState* __tstate = wxPyBeginAllowThreads();
26274 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
26275 wxPyEndAllowThreads(__tstate);
26276 if (PyErr_Occurred()) SWIG_fail;
26277 }
26278 {
26279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26280 }
26281 return resultobj;
26282 fail:
26283 return NULL;
26284 }
26285
26286
26287 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26288 PyObject *resultobj = 0;
26289 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26290 bool arg2 ;
26291 void *argp1 = 0 ;
26292 int res1 = 0 ;
26293 bool val2 ;
26294 int ecode2 = 0 ;
26295 PyObject * obj0 = 0 ;
26296 PyObject * obj1 = 0 ;
26297 char * kwnames[] = {
26298 (char *) "self",(char *) "bIs", NULL
26299 };
26300
26301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
26302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26303 if (!SWIG_IsOK(res1)) {
26304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26305 }
26306 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26307 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26308 if (!SWIG_IsOK(ecode2)) {
26309 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
26310 }
26311 arg2 = static_cast< bool >(val2);
26312 {
26313 PyThreadState* __tstate = wxPyBeginAllowThreads();
26314 (arg1)->SetFromTab(arg2);
26315 wxPyEndAllowThreads(__tstate);
26316 if (PyErr_Occurred()) SWIG_fail;
26317 }
26318 resultobj = SWIG_Py_Void();
26319 return resultobj;
26320 fail:
26321 return NULL;
26322 }
26323
26324
26325 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26326 PyObject *resultobj = 0;
26327 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26328 long arg2 ;
26329 void *argp1 = 0 ;
26330 int res1 = 0 ;
26331 long val2 ;
26332 int ecode2 = 0 ;
26333 PyObject * obj0 = 0 ;
26334 PyObject * obj1 = 0 ;
26335 char * kwnames[] = {
26336 (char *) "self",(char *) "flags", NULL
26337 };
26338
26339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
26340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26341 if (!SWIG_IsOK(res1)) {
26342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26343 }
26344 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26345 ecode2 = SWIG_AsVal_long(obj1, &val2);
26346 if (!SWIG_IsOK(ecode2)) {
26347 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
26348 }
26349 arg2 = static_cast< long >(val2);
26350 {
26351 PyThreadState* __tstate = wxPyBeginAllowThreads();
26352 (arg1)->SetFlags(arg2);
26353 wxPyEndAllowThreads(__tstate);
26354 if (PyErr_Occurred()) SWIG_fail;
26355 }
26356 resultobj = SWIG_Py_Void();
26357 return resultobj;
26358 fail:
26359 return NULL;
26360 }
26361
26362
26363 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26364 PyObject *resultobj = 0;
26365 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26366 wxWindow *result = 0 ;
26367 void *argp1 = 0 ;
26368 int res1 = 0 ;
26369 PyObject *swig_obj[1] ;
26370
26371 if (!args) SWIG_fail;
26372 swig_obj[0] = args;
26373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26374 if (!SWIG_IsOK(res1)) {
26375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26376 }
26377 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26378 {
26379 PyThreadState* __tstate = wxPyBeginAllowThreads();
26380 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
26381 wxPyEndAllowThreads(__tstate);
26382 if (PyErr_Occurred()) SWIG_fail;
26383 }
26384 {
26385 resultobj = wxPyMake_wxObject(result, (bool)0);
26386 }
26387 return resultobj;
26388 fail:
26389 return NULL;
26390 }
26391
26392
26393 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26394 PyObject *resultobj = 0;
26395 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26396 wxWindow *arg2 = (wxWindow *) 0 ;
26397 void *argp1 = 0 ;
26398 int res1 = 0 ;
26399 void *argp2 = 0 ;
26400 int res2 = 0 ;
26401 PyObject * obj0 = 0 ;
26402 PyObject * obj1 = 0 ;
26403 char * kwnames[] = {
26404 (char *) "self",(char *) "win", NULL
26405 };
26406
26407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
26408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26409 if (!SWIG_IsOK(res1)) {
26410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26411 }
26412 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26413 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26414 if (!SWIG_IsOK(res2)) {
26415 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
26416 }
26417 arg2 = reinterpret_cast< wxWindow * >(argp2);
26418 {
26419 PyThreadState* __tstate = wxPyBeginAllowThreads();
26420 (arg1)->SetCurrentFocus(arg2);
26421 wxPyEndAllowThreads(__tstate);
26422 if (PyErr_Occurred()) SWIG_fail;
26423 }
26424 resultobj = SWIG_Py_Void();
26425 return resultobj;
26426 fail:
26427 return NULL;
26428 }
26429
26430
26431 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26432 PyObject *obj;
26433 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26434 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
26435 return SWIG_Py_Void();
26436 }
26437
26438 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26439 return SWIG_Python_InitShadowInstance(args);
26440 }
26441
26442 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26443 PyObject *resultobj = 0;
26444 wxWindow *arg1 = (wxWindow *) NULL ;
26445 wxWindowCreateEvent *result = 0 ;
26446 void *argp1 = 0 ;
26447 int res1 = 0 ;
26448 PyObject * obj0 = 0 ;
26449 char * kwnames[] = {
26450 (char *) "win", NULL
26451 };
26452
26453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
26454 if (obj0) {
26455 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26456 if (!SWIG_IsOK(res1)) {
26457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26458 }
26459 arg1 = reinterpret_cast< wxWindow * >(argp1);
26460 }
26461 {
26462 PyThreadState* __tstate = wxPyBeginAllowThreads();
26463 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
26464 wxPyEndAllowThreads(__tstate);
26465 if (PyErr_Occurred()) SWIG_fail;
26466 }
26467 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
26468 return resultobj;
26469 fail:
26470 return NULL;
26471 }
26472
26473
26474 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26475 PyObject *resultobj = 0;
26476 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
26477 wxWindow *result = 0 ;
26478 void *argp1 = 0 ;
26479 int res1 = 0 ;
26480 PyObject *swig_obj[1] ;
26481
26482 if (!args) SWIG_fail;
26483 swig_obj[0] = args;
26484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
26485 if (!SWIG_IsOK(res1)) {
26486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
26487 }
26488 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
26489 {
26490 PyThreadState* __tstate = wxPyBeginAllowThreads();
26491 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
26492 wxPyEndAllowThreads(__tstate);
26493 if (PyErr_Occurred()) SWIG_fail;
26494 }
26495 {
26496 resultobj = wxPyMake_wxObject(result, (bool)0);
26497 }
26498 return resultobj;
26499 fail:
26500 return NULL;
26501 }
26502
26503
26504 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26505 PyObject *obj;
26506 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26507 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
26508 return SWIG_Py_Void();
26509 }
26510
26511 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26512 return SWIG_Python_InitShadowInstance(args);
26513 }
26514
26515 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26516 PyObject *resultobj = 0;
26517 wxWindow *arg1 = (wxWindow *) NULL ;
26518 wxWindowDestroyEvent *result = 0 ;
26519 void *argp1 = 0 ;
26520 int res1 = 0 ;
26521 PyObject * obj0 = 0 ;
26522 char * kwnames[] = {
26523 (char *) "win", NULL
26524 };
26525
26526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
26527 if (obj0) {
26528 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26529 if (!SWIG_IsOK(res1)) {
26530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26531 }
26532 arg1 = reinterpret_cast< wxWindow * >(argp1);
26533 }
26534 {
26535 PyThreadState* __tstate = wxPyBeginAllowThreads();
26536 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26537 wxPyEndAllowThreads(__tstate);
26538 if (PyErr_Occurred()) SWIG_fail;
26539 }
26540 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
26541 return resultobj;
26542 fail:
26543 return NULL;
26544 }
26545
26546
26547 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26548 PyObject *resultobj = 0;
26549 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
26550 wxWindow *result = 0 ;
26551 void *argp1 = 0 ;
26552 int res1 = 0 ;
26553 PyObject *swig_obj[1] ;
26554
26555 if (!args) SWIG_fail;
26556 swig_obj[0] = args;
26557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
26558 if (!SWIG_IsOK(res1)) {
26559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
26560 }
26561 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
26562 {
26563 PyThreadState* __tstate = wxPyBeginAllowThreads();
26564 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
26565 wxPyEndAllowThreads(__tstate);
26566 if (PyErr_Occurred()) SWIG_fail;
26567 }
26568 {
26569 resultobj = wxPyMake_wxObject(result, (bool)0);
26570 }
26571 return resultobj;
26572 fail:
26573 return NULL;
26574 }
26575
26576
26577 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26578 PyObject *obj;
26579 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26580 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
26581 return SWIG_Py_Void();
26582 }
26583
26584 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26585 return SWIG_Python_InitShadowInstance(args);
26586 }
26587
26588 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26589 PyObject *resultobj = 0;
26590 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26591 int arg2 = (int) 0 ;
26592 wxPoint const &arg3_defvalue = wxDefaultPosition ;
26593 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
26594 wxContextMenuEvent *result = 0 ;
26595 int val1 ;
26596 int ecode1 = 0 ;
26597 int val2 ;
26598 int ecode2 = 0 ;
26599 wxPoint temp3 ;
26600 PyObject * obj0 = 0 ;
26601 PyObject * obj1 = 0 ;
26602 PyObject * obj2 = 0 ;
26603 char * kwnames[] = {
26604 (char *) "type",(char *) "winid",(char *) "pt", NULL
26605 };
26606
26607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26608 if (obj0) {
26609 ecode1 = SWIG_AsVal_int(obj0, &val1);
26610 if (!SWIG_IsOK(ecode1)) {
26611 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26612 }
26613 arg1 = static_cast< wxEventType >(val1);
26614 }
26615 if (obj1) {
26616 ecode2 = SWIG_AsVal_int(obj1, &val2);
26617 if (!SWIG_IsOK(ecode2)) {
26618 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26619 }
26620 arg2 = static_cast< int >(val2);
26621 }
26622 if (obj2) {
26623 {
26624 arg3 = &temp3;
26625 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26626 }
26627 }
26628 {
26629 PyThreadState* __tstate = wxPyBeginAllowThreads();
26630 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26631 wxPyEndAllowThreads(__tstate);
26632 if (PyErr_Occurred()) SWIG_fail;
26633 }
26634 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26635 return resultobj;
26636 fail:
26637 return NULL;
26638 }
26639
26640
26641 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26642 PyObject *resultobj = 0;
26643 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26644 wxPoint *result = 0 ;
26645 void *argp1 = 0 ;
26646 int res1 = 0 ;
26647 PyObject *swig_obj[1] ;
26648
26649 if (!args) SWIG_fail;
26650 swig_obj[0] = args;
26651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26652 if (!SWIG_IsOK(res1)) {
26653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26654 }
26655 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26656 {
26657 PyThreadState* __tstate = wxPyBeginAllowThreads();
26658 {
26659 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26660 result = (wxPoint *) &_result_ref;
26661 }
26662 wxPyEndAllowThreads(__tstate);
26663 if (PyErr_Occurred()) SWIG_fail;
26664 }
26665 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26666 return resultobj;
26667 fail:
26668 return NULL;
26669 }
26670
26671
26672 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26673 PyObject *resultobj = 0;
26674 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26675 wxPoint *arg2 = 0 ;
26676 void *argp1 = 0 ;
26677 int res1 = 0 ;
26678 wxPoint temp2 ;
26679 PyObject * obj0 = 0 ;
26680 PyObject * obj1 = 0 ;
26681 char * kwnames[] = {
26682 (char *) "self",(char *) "pos", NULL
26683 };
26684
26685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26687 if (!SWIG_IsOK(res1)) {
26688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
26689 }
26690 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26691 {
26692 arg2 = &temp2;
26693 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26694 }
26695 {
26696 PyThreadState* __tstate = wxPyBeginAllowThreads();
26697 (arg1)->SetPosition((wxPoint const &)*arg2);
26698 wxPyEndAllowThreads(__tstate);
26699 if (PyErr_Occurred()) SWIG_fail;
26700 }
26701 resultobj = SWIG_Py_Void();
26702 return resultobj;
26703 fail:
26704 return NULL;
26705 }
26706
26707
26708 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26709 PyObject *obj;
26710 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26711 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
26712 return SWIG_Py_Void();
26713 }
26714
26715 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26716 return SWIG_Python_InitShadowInstance(args);
26717 }
26718
26719 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26720 PyObject *resultobj = 0;
26721 wxIdleEvent *result = 0 ;
26722
26723 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
26724 {
26725 PyThreadState* __tstate = wxPyBeginAllowThreads();
26726 result = (wxIdleEvent *)new wxIdleEvent();
26727 wxPyEndAllowThreads(__tstate);
26728 if (PyErr_Occurred()) SWIG_fail;
26729 }
26730 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
26731 return resultobj;
26732 fail:
26733 return NULL;
26734 }
26735
26736
26737 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26738 PyObject *resultobj = 0;
26739 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26740 bool arg2 = (bool) true ;
26741 void *argp1 = 0 ;
26742 int res1 = 0 ;
26743 bool val2 ;
26744 int ecode2 = 0 ;
26745 PyObject * obj0 = 0 ;
26746 PyObject * obj1 = 0 ;
26747 char * kwnames[] = {
26748 (char *) "self",(char *) "needMore", NULL
26749 };
26750
26751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
26752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26753 if (!SWIG_IsOK(res1)) {
26754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
26755 }
26756 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26757 if (obj1) {
26758 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26759 if (!SWIG_IsOK(ecode2)) {
26760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
26761 }
26762 arg2 = static_cast< bool >(val2);
26763 }
26764 {
26765 PyThreadState* __tstate = wxPyBeginAllowThreads();
26766 (arg1)->RequestMore(arg2);
26767 wxPyEndAllowThreads(__tstate);
26768 if (PyErr_Occurred()) SWIG_fail;
26769 }
26770 resultobj = SWIG_Py_Void();
26771 return resultobj;
26772 fail:
26773 return NULL;
26774 }
26775
26776
26777 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26778 PyObject *resultobj = 0;
26779 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26780 bool result;
26781 void *argp1 = 0 ;
26782 int res1 = 0 ;
26783 PyObject *swig_obj[1] ;
26784
26785 if (!args) SWIG_fail;
26786 swig_obj[0] = args;
26787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26788 if (!SWIG_IsOK(res1)) {
26789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
26790 }
26791 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26792 {
26793 PyThreadState* __tstate = wxPyBeginAllowThreads();
26794 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
26795 wxPyEndAllowThreads(__tstate);
26796 if (PyErr_Occurred()) SWIG_fail;
26797 }
26798 {
26799 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26800 }
26801 return resultobj;
26802 fail:
26803 return NULL;
26804 }
26805
26806
26807 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26808 PyObject *resultobj = 0;
26809 wxIdleMode arg1 ;
26810 int val1 ;
26811 int ecode1 = 0 ;
26812 PyObject * obj0 = 0 ;
26813 char * kwnames[] = {
26814 (char *) "mode", NULL
26815 };
26816
26817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26818 ecode1 = SWIG_AsVal_int(obj0, &val1);
26819 if (!SWIG_IsOK(ecode1)) {
26820 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
26821 }
26822 arg1 = static_cast< wxIdleMode >(val1);
26823 {
26824 PyThreadState* __tstate = wxPyBeginAllowThreads();
26825 wxIdleEvent::SetMode(arg1);
26826 wxPyEndAllowThreads(__tstate);
26827 if (PyErr_Occurred()) SWIG_fail;
26828 }
26829 resultobj = SWIG_Py_Void();
26830 return resultobj;
26831 fail:
26832 return NULL;
26833 }
26834
26835
26836 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26837 PyObject *resultobj = 0;
26838 wxIdleMode result;
26839
26840 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
26841 {
26842 PyThreadState* __tstate = wxPyBeginAllowThreads();
26843 result = (wxIdleMode)wxIdleEvent::GetMode();
26844 wxPyEndAllowThreads(__tstate);
26845 if (PyErr_Occurred()) SWIG_fail;
26846 }
26847 resultobj = SWIG_From_int(static_cast< int >(result));
26848 return resultobj;
26849 fail:
26850 return NULL;
26851 }
26852
26853
26854 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26855 PyObject *resultobj = 0;
26856 wxWindow *arg1 = (wxWindow *) 0 ;
26857 bool result;
26858 void *argp1 = 0 ;
26859 int res1 = 0 ;
26860 PyObject * obj0 = 0 ;
26861 char * kwnames[] = {
26862 (char *) "win", NULL
26863 };
26864
26865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
26866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26867 if (!SWIG_IsOK(res1)) {
26868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
26869 }
26870 arg1 = reinterpret_cast< wxWindow * >(argp1);
26871 {
26872 PyThreadState* __tstate = wxPyBeginAllowThreads();
26873 result = (bool)wxIdleEvent::CanSend(arg1);
26874 wxPyEndAllowThreads(__tstate);
26875 if (PyErr_Occurred()) SWIG_fail;
26876 }
26877 {
26878 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26879 }
26880 return resultobj;
26881 fail:
26882 return NULL;
26883 }
26884
26885
26886 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26887 PyObject *obj;
26888 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26889 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
26890 return SWIG_Py_Void();
26891 }
26892
26893 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26894 return SWIG_Python_InitShadowInstance(args);
26895 }
26896
26897 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26898 PyObject *resultobj = 0;
26899 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26900 int arg2 = (int) 0 ;
26901 wxClipboardTextEvent *result = 0 ;
26902 int val1 ;
26903 int ecode1 = 0 ;
26904 int val2 ;
26905 int ecode2 = 0 ;
26906 PyObject * obj0 = 0 ;
26907 PyObject * obj1 = 0 ;
26908 char * kwnames[] = {
26909 (char *) "type",(char *) "winid", NULL
26910 };
26911
26912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26913 if (obj0) {
26914 ecode1 = SWIG_AsVal_int(obj0, &val1);
26915 if (!SWIG_IsOK(ecode1)) {
26916 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26917 }
26918 arg1 = static_cast< wxEventType >(val1);
26919 }
26920 if (obj1) {
26921 ecode2 = SWIG_AsVal_int(obj1, &val2);
26922 if (!SWIG_IsOK(ecode2)) {
26923 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
26924 }
26925 arg2 = static_cast< int >(val2);
26926 }
26927 {
26928 PyThreadState* __tstate = wxPyBeginAllowThreads();
26929 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
26930 wxPyEndAllowThreads(__tstate);
26931 if (PyErr_Occurred()) SWIG_fail;
26932 }
26933 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
26934 return resultobj;
26935 fail:
26936 return NULL;
26937 }
26938
26939
26940 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26941 PyObject *obj;
26942 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26943 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
26944 return SWIG_Py_Void();
26945 }
26946
26947 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26948 return SWIG_Python_InitShadowInstance(args);
26949 }
26950
26951 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26952 PyObject *resultobj = 0;
26953 int arg1 = (int) 0 ;
26954 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26955 wxPyEvent *result = 0 ;
26956 int val1 ;
26957 int ecode1 = 0 ;
26958 int val2 ;
26959 int ecode2 = 0 ;
26960 PyObject * obj0 = 0 ;
26961 PyObject * obj1 = 0 ;
26962 char * kwnames[] = {
26963 (char *) "winid",(char *) "eventType", NULL
26964 };
26965
26966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26967 if (obj0) {
26968 ecode1 = SWIG_AsVal_int(obj0, &val1);
26969 if (!SWIG_IsOK(ecode1)) {
26970 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26971 }
26972 arg1 = static_cast< int >(val1);
26973 }
26974 if (obj1) {
26975 ecode2 = SWIG_AsVal_int(obj1, &val2);
26976 if (!SWIG_IsOK(ecode2)) {
26977 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26978 }
26979 arg2 = static_cast< wxEventType >(val2);
26980 }
26981 {
26982 PyThreadState* __tstate = wxPyBeginAllowThreads();
26983 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26984 wxPyEndAllowThreads(__tstate);
26985 if (PyErr_Occurred()) SWIG_fail;
26986 }
26987 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26988 return resultobj;
26989 fail:
26990 return NULL;
26991 }
26992
26993
26994 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26995 PyObject *resultobj = 0;
26996 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26997 void *argp1 = 0 ;
26998 int res1 = 0 ;
26999 PyObject *swig_obj[1] ;
27000
27001 if (!args) SWIG_fail;
27002 swig_obj[0] = args;
27003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
27004 if (!SWIG_IsOK(res1)) {
27005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
27006 }
27007 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
27008 {
27009 PyThreadState* __tstate = wxPyBeginAllowThreads();
27010 delete arg1;
27011
27012 wxPyEndAllowThreads(__tstate);
27013 if (PyErr_Occurred()) SWIG_fail;
27014 }
27015 resultobj = SWIG_Py_Void();
27016 return resultobj;
27017 fail:
27018 return NULL;
27019 }
27020
27021
27022 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27023 PyObject *resultobj = 0;
27024 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
27025 PyObject *arg2 = (PyObject *) 0 ;
27026 void *argp1 = 0 ;
27027 int res1 = 0 ;
27028 PyObject * obj0 = 0 ;
27029 PyObject * obj1 = 0 ;
27030 char * kwnames[] = {
27031 (char *) "self",(char *) "self", NULL
27032 };
27033
27034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
27035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
27036 if (!SWIG_IsOK(res1)) {
27037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
27038 }
27039 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
27040 arg2 = obj1;
27041 {
27042 PyThreadState* __tstate = wxPyBeginAllowThreads();
27043 (arg1)->SetSelf(arg2);
27044 wxPyEndAllowThreads(__tstate);
27045 if (PyErr_Occurred()) SWIG_fail;
27046 }
27047 resultobj = SWIG_Py_Void();
27048 return resultobj;
27049 fail:
27050 return NULL;
27051 }
27052
27053
27054 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27055 PyObject *resultobj = 0;
27056 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
27057 PyObject *result = 0 ;
27058 void *argp1 = 0 ;
27059 int res1 = 0 ;
27060 PyObject *swig_obj[1] ;
27061
27062 if (!args) SWIG_fail;
27063 swig_obj[0] = args;
27064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
27065 if (!SWIG_IsOK(res1)) {
27066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
27067 }
27068 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
27069 {
27070 PyThreadState* __tstate = wxPyBeginAllowThreads();
27071 result = (PyObject *)(arg1)->GetSelf();
27072 wxPyEndAllowThreads(__tstate);
27073 if (PyErr_Occurred()) SWIG_fail;
27074 }
27075 resultobj = result;
27076 return resultobj;
27077 fail:
27078 return NULL;
27079 }
27080
27081
27082 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27083 PyObject *obj;
27084 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27085 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
27086 return SWIG_Py_Void();
27087 }
27088
27089 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27090 return SWIG_Python_InitShadowInstance(args);
27091 }
27092
27093 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27094 PyObject *resultobj = 0;
27095 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27096 int arg2 = (int) 0 ;
27097 wxPyCommandEvent *result = 0 ;
27098 int val1 ;
27099 int ecode1 = 0 ;
27100 int val2 ;
27101 int ecode2 = 0 ;
27102 PyObject * obj0 = 0 ;
27103 PyObject * obj1 = 0 ;
27104 char * kwnames[] = {
27105 (char *) "eventType",(char *) "id", NULL
27106 };
27107
27108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27109 if (obj0) {
27110 ecode1 = SWIG_AsVal_int(obj0, &val1);
27111 if (!SWIG_IsOK(ecode1)) {
27112 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27113 }
27114 arg1 = static_cast< wxEventType >(val1);
27115 }
27116 if (obj1) {
27117 ecode2 = SWIG_AsVal_int(obj1, &val2);
27118 if (!SWIG_IsOK(ecode2)) {
27119 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
27120 }
27121 arg2 = static_cast< int >(val2);
27122 }
27123 {
27124 PyThreadState* __tstate = wxPyBeginAllowThreads();
27125 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
27126 wxPyEndAllowThreads(__tstate);
27127 if (PyErr_Occurred()) SWIG_fail;
27128 }
27129 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
27130 return resultobj;
27131 fail:
27132 return NULL;
27133 }
27134
27135
27136 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27137 PyObject *resultobj = 0;
27138 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27139 void *argp1 = 0 ;
27140 int res1 = 0 ;
27141 PyObject *swig_obj[1] ;
27142
27143 if (!args) SWIG_fail;
27144 swig_obj[0] = args;
27145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
27146 if (!SWIG_IsOK(res1)) {
27147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27148 }
27149 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27150 {
27151 PyThreadState* __tstate = wxPyBeginAllowThreads();
27152 delete arg1;
27153
27154 wxPyEndAllowThreads(__tstate);
27155 if (PyErr_Occurred()) SWIG_fail;
27156 }
27157 resultobj = SWIG_Py_Void();
27158 return resultobj;
27159 fail:
27160 return NULL;
27161 }
27162
27163
27164 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27165 PyObject *resultobj = 0;
27166 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27167 PyObject *arg2 = (PyObject *) 0 ;
27168 void *argp1 = 0 ;
27169 int res1 = 0 ;
27170 PyObject * obj0 = 0 ;
27171 PyObject * obj1 = 0 ;
27172 char * kwnames[] = {
27173 (char *) "self",(char *) "self", NULL
27174 };
27175
27176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
27177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
27178 if (!SWIG_IsOK(res1)) {
27179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27180 }
27181 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27182 arg2 = obj1;
27183 {
27184 PyThreadState* __tstate = wxPyBeginAllowThreads();
27185 (arg1)->SetSelf(arg2);
27186 wxPyEndAllowThreads(__tstate);
27187 if (PyErr_Occurred()) SWIG_fail;
27188 }
27189 resultobj = SWIG_Py_Void();
27190 return resultobj;
27191 fail:
27192 return NULL;
27193 }
27194
27195
27196 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27197 PyObject *resultobj = 0;
27198 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27199 PyObject *result = 0 ;
27200 void *argp1 = 0 ;
27201 int res1 = 0 ;
27202 PyObject *swig_obj[1] ;
27203
27204 if (!args) SWIG_fail;
27205 swig_obj[0] = args;
27206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
27207 if (!SWIG_IsOK(res1)) {
27208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27209 }
27210 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27211 {
27212 PyThreadState* __tstate = wxPyBeginAllowThreads();
27213 result = (PyObject *)(arg1)->GetSelf();
27214 wxPyEndAllowThreads(__tstate);
27215 if (PyErr_Occurred()) SWIG_fail;
27216 }
27217 resultobj = result;
27218 return resultobj;
27219 fail:
27220 return NULL;
27221 }
27222
27223
27224 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27225 PyObject *obj;
27226 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27227 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
27228 return SWIG_Py_Void();
27229 }
27230
27231 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27232 return SWIG_Python_InitShadowInstance(args);
27233 }
27234
27235 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27236 PyObject *resultobj = 0;
27237 wxWindow *arg1 = (wxWindow *) 0 ;
27238 wxDateTime *arg2 = 0 ;
27239 wxEventType arg3 ;
27240 wxDateEvent *result = 0 ;
27241 void *argp1 = 0 ;
27242 int res1 = 0 ;
27243 void *argp2 = 0 ;
27244 int res2 = 0 ;
27245 int val3 ;
27246 int ecode3 = 0 ;
27247 PyObject * obj0 = 0 ;
27248 PyObject * obj1 = 0 ;
27249 PyObject * obj2 = 0 ;
27250 char * kwnames[] = {
27251 (char *) "win",(char *) "dt",(char *) "type", NULL
27252 };
27253
27254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
27256 if (!SWIG_IsOK(res1)) {
27257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
27258 }
27259 arg1 = reinterpret_cast< wxWindow * >(argp1);
27260 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27261 if (!SWIG_IsOK(res2)) {
27262 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27263 }
27264 if (!argp2) {
27265 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27266 }
27267 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27268 ecode3 = SWIG_AsVal_int(obj2, &val3);
27269 if (!SWIG_IsOK(ecode3)) {
27270 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
27271 }
27272 arg3 = static_cast< wxEventType >(val3);
27273 {
27274 PyThreadState* __tstate = wxPyBeginAllowThreads();
27275 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
27276 wxPyEndAllowThreads(__tstate);
27277 if (PyErr_Occurred()) SWIG_fail;
27278 }
27279 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
27280 return resultobj;
27281 fail:
27282 return NULL;
27283 }
27284
27285
27286 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27287 PyObject *resultobj = 0;
27288 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
27289 wxDateTime *result = 0 ;
27290 void *argp1 = 0 ;
27291 int res1 = 0 ;
27292 PyObject *swig_obj[1] ;
27293
27294 if (!args) SWIG_fail;
27295 swig_obj[0] = args;
27296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27297 if (!SWIG_IsOK(res1)) {
27298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
27299 }
27300 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27301 {
27302 PyThreadState* __tstate = wxPyBeginAllowThreads();
27303 {
27304 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
27305 result = (wxDateTime *) &_result_ref;
27306 }
27307 wxPyEndAllowThreads(__tstate);
27308 if (PyErr_Occurred()) SWIG_fail;
27309 }
27310 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27311 return resultobj;
27312 fail:
27313 return NULL;
27314 }
27315
27316
27317 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27318 PyObject *resultobj = 0;
27319 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
27320 wxDateTime *arg2 = 0 ;
27321 void *argp1 = 0 ;
27322 int res1 = 0 ;
27323 void *argp2 = 0 ;
27324 int res2 = 0 ;
27325 PyObject * obj0 = 0 ;
27326 PyObject * obj1 = 0 ;
27327 char * kwnames[] = {
27328 (char *) "self",(char *) "date", NULL
27329 };
27330
27331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
27332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27333 if (!SWIG_IsOK(res1)) {
27334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
27335 }
27336 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27337 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27338 if (!SWIG_IsOK(res2)) {
27339 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27340 }
27341 if (!argp2) {
27342 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27343 }
27344 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27345 {
27346 PyThreadState* __tstate = wxPyBeginAllowThreads();
27347 (arg1)->SetDate((wxDateTime const &)*arg2);
27348 wxPyEndAllowThreads(__tstate);
27349 if (PyErr_Occurred()) SWIG_fail;
27350 }
27351 resultobj = SWIG_Py_Void();
27352 return resultobj;
27353 fail:
27354 return NULL;
27355 }
27356
27357
27358 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27359 PyObject *obj;
27360 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27361 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
27362 return SWIG_Py_Void();
27363 }
27364
27365 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27366 return SWIG_Python_InitShadowInstance(args);
27367 }
27368
27369 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27370 PyObject *resultobj = 0;
27371 wxPyApp *result = 0 ;
27372
27373 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
27374 {
27375 PyThreadState* __tstate = wxPyBeginAllowThreads();
27376 result = (wxPyApp *)new_wxPyApp();
27377 wxPyEndAllowThreads(__tstate);
27378 if (PyErr_Occurred()) SWIG_fail;
27379 }
27380 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
27381 return resultobj;
27382 fail:
27383 return NULL;
27384 }
27385
27386
27387 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27388 PyObject *resultobj = 0;
27389 wxPyApp *arg1 = (wxPyApp *) 0 ;
27390 void *argp1 = 0 ;
27391 int res1 = 0 ;
27392 PyObject *swig_obj[1] ;
27393
27394 if (!args) SWIG_fail;
27395 swig_obj[0] = args;
27396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
27397 if (!SWIG_IsOK(res1)) {
27398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
27399 }
27400 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27401 {
27402 PyThreadState* __tstate = wxPyBeginAllowThreads();
27403 delete arg1;
27404
27405 wxPyEndAllowThreads(__tstate);
27406 if (PyErr_Occurred()) SWIG_fail;
27407 }
27408 resultobj = SWIG_Py_Void();
27409 return resultobj;
27410 fail:
27411 return NULL;
27412 }
27413
27414
27415 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27416 PyObject *resultobj = 0;
27417 wxPyApp *arg1 = (wxPyApp *) 0 ;
27418 PyObject *arg2 = (PyObject *) 0 ;
27419 PyObject *arg3 = (PyObject *) 0 ;
27420 bool arg4 ;
27421 void *argp1 = 0 ;
27422 int res1 = 0 ;
27423 bool val4 ;
27424 int ecode4 = 0 ;
27425 PyObject * obj0 = 0 ;
27426 PyObject * obj1 = 0 ;
27427 PyObject * obj2 = 0 ;
27428 PyObject * obj3 = 0 ;
27429 char * kwnames[] = {
27430 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
27431 };
27432
27433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27435 if (!SWIG_IsOK(res1)) {
27436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
27437 }
27438 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27439 arg2 = obj1;
27440 arg3 = obj2;
27441 ecode4 = SWIG_AsVal_bool(obj3, &val4);
27442 if (!SWIG_IsOK(ecode4)) {
27443 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
27444 }
27445 arg4 = static_cast< bool >(val4);
27446 {
27447 PyThreadState* __tstate = wxPyBeginAllowThreads();
27448 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
27449 wxPyEndAllowThreads(__tstate);
27450 if (PyErr_Occurred()) SWIG_fail;
27451 }
27452 resultobj = SWIG_Py_Void();
27453 return resultobj;
27454 fail:
27455 return NULL;
27456 }
27457
27458
27459 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27460 PyObject *resultobj = 0;
27461 wxPyApp *arg1 = (wxPyApp *) 0 ;
27462 wxString result;
27463 void *argp1 = 0 ;
27464 int res1 = 0 ;
27465 PyObject *swig_obj[1] ;
27466
27467 if (!args) SWIG_fail;
27468 swig_obj[0] = args;
27469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27470 if (!SWIG_IsOK(res1)) {
27471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27472 }
27473 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27474 {
27475 PyThreadState* __tstate = wxPyBeginAllowThreads();
27476 result = ((wxPyApp const *)arg1)->GetAppName();
27477 wxPyEndAllowThreads(__tstate);
27478 if (PyErr_Occurred()) SWIG_fail;
27479 }
27480 {
27481 #if wxUSE_UNICODE
27482 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27483 #else
27484 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27485 #endif
27486 }
27487 return resultobj;
27488 fail:
27489 return NULL;
27490 }
27491
27492
27493 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27494 PyObject *resultobj = 0;
27495 wxPyApp *arg1 = (wxPyApp *) 0 ;
27496 wxString *arg2 = 0 ;
27497 void *argp1 = 0 ;
27498 int res1 = 0 ;
27499 bool temp2 = false ;
27500 PyObject * obj0 = 0 ;
27501 PyObject * obj1 = 0 ;
27502 char * kwnames[] = {
27503 (char *) "self",(char *) "name", NULL
27504 };
27505
27506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
27507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27508 if (!SWIG_IsOK(res1)) {
27509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27510 }
27511 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27512 {
27513 arg2 = wxString_in_helper(obj1);
27514 if (arg2 == NULL) SWIG_fail;
27515 temp2 = true;
27516 }
27517 {
27518 PyThreadState* __tstate = wxPyBeginAllowThreads();
27519 (arg1)->SetAppName((wxString const &)*arg2);
27520 wxPyEndAllowThreads(__tstate);
27521 if (PyErr_Occurred()) SWIG_fail;
27522 }
27523 resultobj = SWIG_Py_Void();
27524 {
27525 if (temp2)
27526 delete arg2;
27527 }
27528 return resultobj;
27529 fail:
27530 {
27531 if (temp2)
27532 delete arg2;
27533 }
27534 return NULL;
27535 }
27536
27537
27538 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27539 PyObject *resultobj = 0;
27540 wxPyApp *arg1 = (wxPyApp *) 0 ;
27541 wxString result;
27542 void *argp1 = 0 ;
27543 int res1 = 0 ;
27544 PyObject *swig_obj[1] ;
27545
27546 if (!args) SWIG_fail;
27547 swig_obj[0] = args;
27548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27549 if (!SWIG_IsOK(res1)) {
27550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27551 }
27552 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27553 {
27554 PyThreadState* __tstate = wxPyBeginAllowThreads();
27555 result = ((wxPyApp const *)arg1)->GetClassName();
27556 wxPyEndAllowThreads(__tstate);
27557 if (PyErr_Occurred()) SWIG_fail;
27558 }
27559 {
27560 #if wxUSE_UNICODE
27561 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27562 #else
27563 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27564 #endif
27565 }
27566 return resultobj;
27567 fail:
27568 return NULL;
27569 }
27570
27571
27572 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27573 PyObject *resultobj = 0;
27574 wxPyApp *arg1 = (wxPyApp *) 0 ;
27575 wxString *arg2 = 0 ;
27576 void *argp1 = 0 ;
27577 int res1 = 0 ;
27578 bool temp2 = false ;
27579 PyObject * obj0 = 0 ;
27580 PyObject * obj1 = 0 ;
27581 char * kwnames[] = {
27582 (char *) "self",(char *) "name", NULL
27583 };
27584
27585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
27586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27587 if (!SWIG_IsOK(res1)) {
27588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27589 }
27590 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27591 {
27592 arg2 = wxString_in_helper(obj1);
27593 if (arg2 == NULL) SWIG_fail;
27594 temp2 = true;
27595 }
27596 {
27597 PyThreadState* __tstate = wxPyBeginAllowThreads();
27598 (arg1)->SetClassName((wxString const &)*arg2);
27599 wxPyEndAllowThreads(__tstate);
27600 if (PyErr_Occurred()) SWIG_fail;
27601 }
27602 resultobj = SWIG_Py_Void();
27603 {
27604 if (temp2)
27605 delete arg2;
27606 }
27607 return resultobj;
27608 fail:
27609 {
27610 if (temp2)
27611 delete arg2;
27612 }
27613 return NULL;
27614 }
27615
27616
27617 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27618 PyObject *resultobj = 0;
27619 wxPyApp *arg1 = (wxPyApp *) 0 ;
27620 wxString *result = 0 ;
27621 void *argp1 = 0 ;
27622 int res1 = 0 ;
27623 PyObject *swig_obj[1] ;
27624
27625 if (!args) SWIG_fail;
27626 swig_obj[0] = args;
27627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27628 if (!SWIG_IsOK(res1)) {
27629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27630 }
27631 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27632 {
27633 PyThreadState* __tstate = wxPyBeginAllowThreads();
27634 {
27635 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
27636 result = (wxString *) &_result_ref;
27637 }
27638 wxPyEndAllowThreads(__tstate);
27639 if (PyErr_Occurred()) SWIG_fail;
27640 }
27641 {
27642 #if wxUSE_UNICODE
27643 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
27644 #else
27645 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
27646 #endif
27647 }
27648 return resultobj;
27649 fail:
27650 return NULL;
27651 }
27652
27653
27654 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27655 PyObject *resultobj = 0;
27656 wxPyApp *arg1 = (wxPyApp *) 0 ;
27657 wxString *arg2 = 0 ;
27658 void *argp1 = 0 ;
27659 int res1 = 0 ;
27660 bool temp2 = false ;
27661 PyObject * obj0 = 0 ;
27662 PyObject * obj1 = 0 ;
27663 char * kwnames[] = {
27664 (char *) "self",(char *) "name", NULL
27665 };
27666
27667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27669 if (!SWIG_IsOK(res1)) {
27670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27671 }
27672 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27673 {
27674 arg2 = wxString_in_helper(obj1);
27675 if (arg2 == NULL) SWIG_fail;
27676 temp2 = true;
27677 }
27678 {
27679 PyThreadState* __tstate = wxPyBeginAllowThreads();
27680 (arg1)->SetVendorName((wxString const &)*arg2);
27681 wxPyEndAllowThreads(__tstate);
27682 if (PyErr_Occurred()) SWIG_fail;
27683 }
27684 resultobj = SWIG_Py_Void();
27685 {
27686 if (temp2)
27687 delete arg2;
27688 }
27689 return resultobj;
27690 fail:
27691 {
27692 if (temp2)
27693 delete arg2;
27694 }
27695 return NULL;
27696 }
27697
27698
27699 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27700 PyObject *resultobj = 0;
27701 wxPyApp *arg1 = (wxPyApp *) 0 ;
27702 wxAppTraits *result = 0 ;
27703 void *argp1 = 0 ;
27704 int res1 = 0 ;
27705 PyObject *swig_obj[1] ;
27706
27707 if (!args) SWIG_fail;
27708 swig_obj[0] = args;
27709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27710 if (!SWIG_IsOK(res1)) {
27711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27712 }
27713 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27714 {
27715 PyThreadState* __tstate = wxPyBeginAllowThreads();
27716 result = (wxAppTraits *)(arg1)->GetTraits();
27717 wxPyEndAllowThreads(__tstate);
27718 if (PyErr_Occurred()) SWIG_fail;
27719 }
27720 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27721 return resultobj;
27722 fail:
27723 return NULL;
27724 }
27725
27726
27727 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27728 PyObject *resultobj = 0;
27729 wxPyApp *arg1 = (wxPyApp *) 0 ;
27730 void *argp1 = 0 ;
27731 int res1 = 0 ;
27732 PyObject *swig_obj[1] ;
27733
27734 if (!args) SWIG_fail;
27735 swig_obj[0] = args;
27736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27737 if (!SWIG_IsOK(res1)) {
27738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27739 }
27740 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27741 {
27742 PyThreadState* __tstate = wxPyBeginAllowThreads();
27743 (arg1)->ProcessPendingEvents();
27744 wxPyEndAllowThreads(__tstate);
27745 if (PyErr_Occurred()) SWIG_fail;
27746 }
27747 resultobj = SWIG_Py_Void();
27748 return resultobj;
27749 fail:
27750 return NULL;
27751 }
27752
27753
27754 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27755 PyObject *resultobj = 0;
27756 wxPyApp *arg1 = (wxPyApp *) 0 ;
27757 bool arg2 = (bool) false ;
27758 bool result;
27759 void *argp1 = 0 ;
27760 int res1 = 0 ;
27761 bool val2 ;
27762 int ecode2 = 0 ;
27763 PyObject * obj0 = 0 ;
27764 PyObject * obj1 = 0 ;
27765 char * kwnames[] = {
27766 (char *) "self",(char *) "onlyIfNeeded", NULL
27767 };
27768
27769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27771 if (!SWIG_IsOK(res1)) {
27772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27773 }
27774 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27775 if (obj1) {
27776 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27777 if (!SWIG_IsOK(ecode2)) {
27778 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27779 }
27780 arg2 = static_cast< bool >(val2);
27781 }
27782 {
27783 PyThreadState* __tstate = wxPyBeginAllowThreads();
27784 result = (bool)(arg1)->Yield(arg2);
27785 wxPyEndAllowThreads(__tstate);
27786 if (PyErr_Occurred()) SWIG_fail;
27787 }
27788 {
27789 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27790 }
27791 return resultobj;
27792 fail:
27793 return NULL;
27794 }
27795
27796
27797 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27798 PyObject *resultobj = 0;
27799 wxPyApp *arg1 = (wxPyApp *) 0 ;
27800 void *argp1 = 0 ;
27801 int res1 = 0 ;
27802 PyObject *swig_obj[1] ;
27803
27804 if (!args) SWIG_fail;
27805 swig_obj[0] = args;
27806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27807 if (!SWIG_IsOK(res1)) {
27808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27809 }
27810 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27811 {
27812 PyThreadState* __tstate = wxPyBeginAllowThreads();
27813 (arg1)->WakeUpIdle();
27814 wxPyEndAllowThreads(__tstate);
27815 if (PyErr_Occurred()) SWIG_fail;
27816 }
27817 resultobj = SWIG_Py_Void();
27818 return resultobj;
27819 fail:
27820 return NULL;
27821 }
27822
27823
27824 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27825 PyObject *resultobj = 0;
27826 bool result;
27827
27828 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27829 {
27830 PyThreadState* __tstate = wxPyBeginAllowThreads();
27831 result = (bool)wxPyApp::IsMainLoopRunning();
27832 wxPyEndAllowThreads(__tstate);
27833 if (PyErr_Occurred()) SWIG_fail;
27834 }
27835 {
27836 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27837 }
27838 return resultobj;
27839 fail:
27840 return NULL;
27841 }
27842
27843
27844 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27845 PyObject *resultobj = 0;
27846 wxPyApp *arg1 = (wxPyApp *) 0 ;
27847 int result;
27848 void *argp1 = 0 ;
27849 int res1 = 0 ;
27850 PyObject *swig_obj[1] ;
27851
27852 if (!args) SWIG_fail;
27853 swig_obj[0] = args;
27854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27855 if (!SWIG_IsOK(res1)) {
27856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27857 }
27858 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27859 {
27860 PyThreadState* __tstate = wxPyBeginAllowThreads();
27861 result = (int)(arg1)->MainLoop();
27862 wxPyEndAllowThreads(__tstate);
27863 if (PyErr_Occurred()) SWIG_fail;
27864 }
27865 resultobj = SWIG_From_int(static_cast< int >(result));
27866 return resultobj;
27867 fail:
27868 return NULL;
27869 }
27870
27871
27872 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27873 PyObject *resultobj = 0;
27874 wxPyApp *arg1 = (wxPyApp *) 0 ;
27875 void *argp1 = 0 ;
27876 int res1 = 0 ;
27877 PyObject *swig_obj[1] ;
27878
27879 if (!args) SWIG_fail;
27880 swig_obj[0] = args;
27881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27882 if (!SWIG_IsOK(res1)) {
27883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27884 }
27885 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27886 {
27887 PyThreadState* __tstate = wxPyBeginAllowThreads();
27888 (arg1)->Exit();
27889 wxPyEndAllowThreads(__tstate);
27890 if (PyErr_Occurred()) SWIG_fail;
27891 }
27892 resultobj = SWIG_Py_Void();
27893 return resultobj;
27894 fail:
27895 return NULL;
27896 }
27897
27898
27899 SWIGINTERN PyObject *_wrap_PyApp_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27900 PyObject *resultobj = 0;
27901 wxPyApp *arg1 = (wxPyApp *) 0 ;
27902 wxLayoutDirection result;
27903 void *argp1 = 0 ;
27904 int res1 = 0 ;
27905 PyObject *swig_obj[1] ;
27906
27907 if (!args) SWIG_fail;
27908 swig_obj[0] = args;
27909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27910 if (!SWIG_IsOK(res1)) {
27911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetLayoutDirection" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27912 }
27913 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27914 {
27915 PyThreadState* __tstate = wxPyBeginAllowThreads();
27916 result = (wxLayoutDirection)((wxPyApp const *)arg1)->GetLayoutDirection();
27917 wxPyEndAllowThreads(__tstate);
27918 if (PyErr_Occurred()) SWIG_fail;
27919 }
27920 resultobj = SWIG_From_int(static_cast< int >(result));
27921 return resultobj;
27922 fail:
27923 return NULL;
27924 }
27925
27926
27927 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27928 PyObject *resultobj = 0;
27929 wxPyApp *arg1 = (wxPyApp *) 0 ;
27930 void *argp1 = 0 ;
27931 int res1 = 0 ;
27932 PyObject *swig_obj[1] ;
27933
27934 if (!args) SWIG_fail;
27935 swig_obj[0] = args;
27936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27937 if (!SWIG_IsOK(res1)) {
27938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27939 }
27940 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27941 {
27942 PyThreadState* __tstate = wxPyBeginAllowThreads();
27943 (arg1)->ExitMainLoop();
27944 wxPyEndAllowThreads(__tstate);
27945 if (PyErr_Occurred()) SWIG_fail;
27946 }
27947 resultobj = SWIG_Py_Void();
27948 return resultobj;
27949 fail:
27950 return NULL;
27951 }
27952
27953
27954 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27955 PyObject *resultobj = 0;
27956 wxPyApp *arg1 = (wxPyApp *) 0 ;
27957 bool result;
27958 void *argp1 = 0 ;
27959 int res1 = 0 ;
27960 PyObject *swig_obj[1] ;
27961
27962 if (!args) SWIG_fail;
27963 swig_obj[0] = args;
27964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27965 if (!SWIG_IsOK(res1)) {
27966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27967 }
27968 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27969 {
27970 PyThreadState* __tstate = wxPyBeginAllowThreads();
27971 result = (bool)(arg1)->Pending();
27972 wxPyEndAllowThreads(__tstate);
27973 if (PyErr_Occurred()) SWIG_fail;
27974 }
27975 {
27976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27977 }
27978 return resultobj;
27979 fail:
27980 return NULL;
27981 }
27982
27983
27984 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27985 PyObject *resultobj = 0;
27986 wxPyApp *arg1 = (wxPyApp *) 0 ;
27987 bool result;
27988 void *argp1 = 0 ;
27989 int res1 = 0 ;
27990 PyObject *swig_obj[1] ;
27991
27992 if (!args) SWIG_fail;
27993 swig_obj[0] = args;
27994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27995 if (!SWIG_IsOK(res1)) {
27996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27997 }
27998 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27999 {
28000 PyThreadState* __tstate = wxPyBeginAllowThreads();
28001 result = (bool)(arg1)->Dispatch();
28002 wxPyEndAllowThreads(__tstate);
28003 if (PyErr_Occurred()) SWIG_fail;
28004 }
28005 {
28006 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28007 }
28008 return resultobj;
28009 fail:
28010 return NULL;
28011 }
28012
28013
28014 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28015 PyObject *resultobj = 0;
28016 wxPyApp *arg1 = (wxPyApp *) 0 ;
28017 bool result;
28018 void *argp1 = 0 ;
28019 int res1 = 0 ;
28020 PyObject *swig_obj[1] ;
28021
28022 if (!args) SWIG_fail;
28023 swig_obj[0] = args;
28024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28025 if (!SWIG_IsOK(res1)) {
28026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
28027 }
28028 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28029 {
28030 PyThreadState* __tstate = wxPyBeginAllowThreads();
28031 result = (bool)(arg1)->ProcessIdle();
28032 wxPyEndAllowThreads(__tstate);
28033 if (PyErr_Occurred()) SWIG_fail;
28034 }
28035 {
28036 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28037 }
28038 return resultobj;
28039 fail:
28040 return NULL;
28041 }
28042
28043
28044 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28045 PyObject *resultobj = 0;
28046 wxPyApp *arg1 = (wxPyApp *) 0 ;
28047 wxWindow *arg2 = (wxWindow *) 0 ;
28048 wxIdleEvent *arg3 = 0 ;
28049 bool result;
28050 void *argp1 = 0 ;
28051 int res1 = 0 ;
28052 void *argp2 = 0 ;
28053 int res2 = 0 ;
28054 void *argp3 = 0 ;
28055 int res3 = 0 ;
28056 PyObject * obj0 = 0 ;
28057 PyObject * obj1 = 0 ;
28058 PyObject * obj2 = 0 ;
28059 char * kwnames[] = {
28060 (char *) "self",(char *) "win",(char *) "event", NULL
28061 };
28062
28063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28065 if (!SWIG_IsOK(res1)) {
28066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
28067 }
28068 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28069 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28070 if (!SWIG_IsOK(res2)) {
28071 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
28072 }
28073 arg2 = reinterpret_cast< wxWindow * >(argp2);
28074 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
28075 if (!SWIG_IsOK(res3)) {
28076 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
28077 }
28078 if (!argp3) {
28079 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
28080 }
28081 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
28082 {
28083 PyThreadState* __tstate = wxPyBeginAllowThreads();
28084 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
28085 wxPyEndAllowThreads(__tstate);
28086 if (PyErr_Occurred()) SWIG_fail;
28087 }
28088 {
28089 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28090 }
28091 return resultobj;
28092 fail:
28093 return NULL;
28094 }
28095
28096
28097 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28098 PyObject *resultobj = 0;
28099 wxPyApp *arg1 = (wxPyApp *) 0 ;
28100 bool result;
28101 void *argp1 = 0 ;
28102 int res1 = 0 ;
28103 PyObject *swig_obj[1] ;
28104
28105 if (!args) SWIG_fail;
28106 swig_obj[0] = args;
28107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28108 if (!SWIG_IsOK(res1)) {
28109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28110 }
28111 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28112 {
28113 PyThreadState* __tstate = wxPyBeginAllowThreads();
28114 result = (bool)((wxPyApp const *)arg1)->IsActive();
28115 wxPyEndAllowThreads(__tstate);
28116 if (PyErr_Occurred()) SWIG_fail;
28117 }
28118 {
28119 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28120 }
28121 return resultobj;
28122 fail:
28123 return NULL;
28124 }
28125
28126
28127 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28128 PyObject *resultobj = 0;
28129 wxPyApp *arg1 = (wxPyApp *) 0 ;
28130 wxWindow *arg2 = (wxWindow *) 0 ;
28131 void *argp1 = 0 ;
28132 int res1 = 0 ;
28133 void *argp2 = 0 ;
28134 int res2 = 0 ;
28135 PyObject * obj0 = 0 ;
28136 PyObject * obj1 = 0 ;
28137 char * kwnames[] = {
28138 (char *) "self",(char *) "win", NULL
28139 };
28140
28141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
28142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28143 if (!SWIG_IsOK(res1)) {
28144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
28145 }
28146 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28147 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28148 if (!SWIG_IsOK(res2)) {
28149 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
28150 }
28151 arg2 = reinterpret_cast< wxWindow * >(argp2);
28152 {
28153 PyThreadState* __tstate = wxPyBeginAllowThreads();
28154 (arg1)->SetTopWindow(arg2);
28155 wxPyEndAllowThreads(__tstate);
28156 if (PyErr_Occurred()) SWIG_fail;
28157 }
28158 resultobj = SWIG_Py_Void();
28159 return resultobj;
28160 fail:
28161 return NULL;
28162 }
28163
28164
28165 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28166 PyObject *resultobj = 0;
28167 wxPyApp *arg1 = (wxPyApp *) 0 ;
28168 wxWindow *result = 0 ;
28169 void *argp1 = 0 ;
28170 int res1 = 0 ;
28171 PyObject *swig_obj[1] ;
28172
28173 if (!args) SWIG_fail;
28174 swig_obj[0] = args;
28175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28176 if (!SWIG_IsOK(res1)) {
28177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28178 }
28179 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28180 {
28181 PyThreadState* __tstate = wxPyBeginAllowThreads();
28182 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
28183 wxPyEndAllowThreads(__tstate);
28184 if (PyErr_Occurred()) SWIG_fail;
28185 }
28186 {
28187 resultobj = wxPyMake_wxObject(result, (bool)0);
28188 }
28189 return resultobj;
28190 fail:
28191 return NULL;
28192 }
28193
28194
28195 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28196 PyObject *resultobj = 0;
28197 wxPyApp *arg1 = (wxPyApp *) 0 ;
28198 bool arg2 ;
28199 void *argp1 = 0 ;
28200 int res1 = 0 ;
28201 bool val2 ;
28202 int ecode2 = 0 ;
28203 PyObject * obj0 = 0 ;
28204 PyObject * obj1 = 0 ;
28205 char * kwnames[] = {
28206 (char *) "self",(char *) "flag", NULL
28207 };
28208
28209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
28210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28211 if (!SWIG_IsOK(res1)) {
28212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
28213 }
28214 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28215 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28216 if (!SWIG_IsOK(ecode2)) {
28217 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
28218 }
28219 arg2 = static_cast< bool >(val2);
28220 {
28221 PyThreadState* __tstate = wxPyBeginAllowThreads();
28222 (arg1)->SetExitOnFrameDelete(arg2);
28223 wxPyEndAllowThreads(__tstate);
28224 if (PyErr_Occurred()) SWIG_fail;
28225 }
28226 resultobj = SWIG_Py_Void();
28227 return resultobj;
28228 fail:
28229 return NULL;
28230 }
28231
28232
28233 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28234 PyObject *resultobj = 0;
28235 wxPyApp *arg1 = (wxPyApp *) 0 ;
28236 bool result;
28237 void *argp1 = 0 ;
28238 int res1 = 0 ;
28239 PyObject *swig_obj[1] ;
28240
28241 if (!args) SWIG_fail;
28242 swig_obj[0] = args;
28243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28244 if (!SWIG_IsOK(res1)) {
28245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28246 }
28247 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28248 {
28249 PyThreadState* __tstate = wxPyBeginAllowThreads();
28250 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
28251 wxPyEndAllowThreads(__tstate);
28252 if (PyErr_Occurred()) SWIG_fail;
28253 }
28254 {
28255 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28256 }
28257 return resultobj;
28258 fail:
28259 return NULL;
28260 }
28261
28262
28263 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28264 PyObject *resultobj = 0;
28265 wxPyApp *arg1 = (wxPyApp *) 0 ;
28266 bool arg2 ;
28267 void *argp1 = 0 ;
28268 int res1 = 0 ;
28269 bool val2 ;
28270 int ecode2 = 0 ;
28271 PyObject * obj0 = 0 ;
28272 PyObject * obj1 = 0 ;
28273 char * kwnames[] = {
28274 (char *) "self",(char *) "flag", NULL
28275 };
28276
28277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
28278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28279 if (!SWIG_IsOK(res1)) {
28280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
28281 }
28282 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28283 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28284 if (!SWIG_IsOK(ecode2)) {
28285 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
28286 }
28287 arg2 = static_cast< bool >(val2);
28288 {
28289 PyThreadState* __tstate = wxPyBeginAllowThreads();
28290 (arg1)->SetUseBestVisual(arg2);
28291 wxPyEndAllowThreads(__tstate);
28292 if (PyErr_Occurred()) SWIG_fail;
28293 }
28294 resultobj = SWIG_Py_Void();
28295 return resultobj;
28296 fail:
28297 return NULL;
28298 }
28299
28300
28301 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28302 PyObject *resultobj = 0;
28303 wxPyApp *arg1 = (wxPyApp *) 0 ;
28304 bool result;
28305 void *argp1 = 0 ;
28306 int res1 = 0 ;
28307 PyObject *swig_obj[1] ;
28308
28309 if (!args) SWIG_fail;
28310 swig_obj[0] = args;
28311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28312 if (!SWIG_IsOK(res1)) {
28313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28314 }
28315 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28316 {
28317 PyThreadState* __tstate = wxPyBeginAllowThreads();
28318 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
28319 wxPyEndAllowThreads(__tstate);
28320 if (PyErr_Occurred()) SWIG_fail;
28321 }
28322 {
28323 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28324 }
28325 return resultobj;
28326 fail:
28327 return NULL;
28328 }
28329
28330
28331 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28332 PyObject *resultobj = 0;
28333 wxPyApp *arg1 = (wxPyApp *) 0 ;
28334 int arg2 ;
28335 void *argp1 = 0 ;
28336 int res1 = 0 ;
28337 int val2 ;
28338 int ecode2 = 0 ;
28339 PyObject * obj0 = 0 ;
28340 PyObject * obj1 = 0 ;
28341 char * kwnames[] = {
28342 (char *) "self",(char *) "mode", NULL
28343 };
28344
28345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
28346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28347 if (!SWIG_IsOK(res1)) {
28348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28349 }
28350 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28351 ecode2 = SWIG_AsVal_int(obj1, &val2);
28352 if (!SWIG_IsOK(ecode2)) {
28353 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
28354 }
28355 arg2 = static_cast< int >(val2);
28356 {
28357 PyThreadState* __tstate = wxPyBeginAllowThreads();
28358 (arg1)->SetPrintMode(arg2);
28359 wxPyEndAllowThreads(__tstate);
28360 if (PyErr_Occurred()) SWIG_fail;
28361 }
28362 resultobj = SWIG_Py_Void();
28363 return resultobj;
28364 fail:
28365 return NULL;
28366 }
28367
28368
28369 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28370 PyObject *resultobj = 0;
28371 wxPyApp *arg1 = (wxPyApp *) 0 ;
28372 int result;
28373 void *argp1 = 0 ;
28374 int res1 = 0 ;
28375 PyObject *swig_obj[1] ;
28376
28377 if (!args) SWIG_fail;
28378 swig_obj[0] = args;
28379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28380 if (!SWIG_IsOK(res1)) {
28381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28382 }
28383 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28384 {
28385 PyThreadState* __tstate = wxPyBeginAllowThreads();
28386 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
28387 wxPyEndAllowThreads(__tstate);
28388 if (PyErr_Occurred()) SWIG_fail;
28389 }
28390 resultobj = SWIG_From_int(static_cast< int >(result));
28391 return resultobj;
28392 fail:
28393 return NULL;
28394 }
28395
28396
28397 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28398 PyObject *resultobj = 0;
28399 wxPyApp *arg1 = (wxPyApp *) 0 ;
28400 int arg2 ;
28401 void *argp1 = 0 ;
28402 int res1 = 0 ;
28403 int val2 ;
28404 int ecode2 = 0 ;
28405 PyObject * obj0 = 0 ;
28406 PyObject * obj1 = 0 ;
28407 char * kwnames[] = {
28408 (char *) "self",(char *) "mode", NULL
28409 };
28410
28411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
28412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28413 if (!SWIG_IsOK(res1)) {
28414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28415 }
28416 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28417 ecode2 = SWIG_AsVal_int(obj1, &val2);
28418 if (!SWIG_IsOK(ecode2)) {
28419 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
28420 }
28421 arg2 = static_cast< int >(val2);
28422 {
28423 PyThreadState* __tstate = wxPyBeginAllowThreads();
28424 (arg1)->SetAssertMode(arg2);
28425 wxPyEndAllowThreads(__tstate);
28426 if (PyErr_Occurred()) SWIG_fail;
28427 }
28428 resultobj = SWIG_Py_Void();
28429 return resultobj;
28430 fail:
28431 return NULL;
28432 }
28433
28434
28435 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28436 PyObject *resultobj = 0;
28437 wxPyApp *arg1 = (wxPyApp *) 0 ;
28438 int result;
28439 void *argp1 = 0 ;
28440 int res1 = 0 ;
28441 PyObject *swig_obj[1] ;
28442
28443 if (!args) SWIG_fail;
28444 swig_obj[0] = args;
28445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28446 if (!SWIG_IsOK(res1)) {
28447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28448 }
28449 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28450 {
28451 PyThreadState* __tstate = wxPyBeginAllowThreads();
28452 result = (int)(arg1)->GetAssertMode();
28453 wxPyEndAllowThreads(__tstate);
28454 if (PyErr_Occurred()) SWIG_fail;
28455 }
28456 resultobj = SWIG_From_int(static_cast< int >(result));
28457 return resultobj;
28458 fail:
28459 return NULL;
28460 }
28461
28462
28463 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28464 PyObject *resultobj = 0;
28465 bool result;
28466
28467 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
28468 {
28469 PyThreadState* __tstate = wxPyBeginAllowThreads();
28470 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
28471 wxPyEndAllowThreads(__tstate);
28472 if (PyErr_Occurred()) SWIG_fail;
28473 }
28474 {
28475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28476 }
28477 return resultobj;
28478 fail:
28479 return NULL;
28480 }
28481
28482
28483 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28484 PyObject *resultobj = 0;
28485 long result;
28486
28487 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
28488 {
28489 PyThreadState* __tstate = wxPyBeginAllowThreads();
28490 result = (long)wxPyApp::GetMacAboutMenuItemId();
28491 wxPyEndAllowThreads(__tstate);
28492 if (PyErr_Occurred()) SWIG_fail;
28493 }
28494 resultobj = SWIG_From_long(static_cast< long >(result));
28495 return resultobj;
28496 fail:
28497 return NULL;
28498 }
28499
28500
28501 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28502 PyObject *resultobj = 0;
28503 long result;
28504
28505 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
28506 {
28507 PyThreadState* __tstate = wxPyBeginAllowThreads();
28508 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
28509 wxPyEndAllowThreads(__tstate);
28510 if (PyErr_Occurred()) SWIG_fail;
28511 }
28512 resultobj = SWIG_From_long(static_cast< long >(result));
28513 return resultobj;
28514 fail:
28515 return NULL;
28516 }
28517
28518
28519 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28520 PyObject *resultobj = 0;
28521 long result;
28522
28523 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
28524 {
28525 PyThreadState* __tstate = wxPyBeginAllowThreads();
28526 result = (long)wxPyApp::GetMacExitMenuItemId();
28527 wxPyEndAllowThreads(__tstate);
28528 if (PyErr_Occurred()) SWIG_fail;
28529 }
28530 resultobj = SWIG_From_long(static_cast< long >(result));
28531 return resultobj;
28532 fail:
28533 return NULL;
28534 }
28535
28536
28537 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28538 PyObject *resultobj = 0;
28539 wxString result;
28540
28541 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
28542 {
28543 PyThreadState* __tstate = wxPyBeginAllowThreads();
28544 result = wxPyApp::GetMacHelpMenuTitleName();
28545 wxPyEndAllowThreads(__tstate);
28546 if (PyErr_Occurred()) SWIG_fail;
28547 }
28548 {
28549 #if wxUSE_UNICODE
28550 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28551 #else
28552 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28553 #endif
28554 }
28555 return resultobj;
28556 fail:
28557 return NULL;
28558 }
28559
28560
28561 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28562 PyObject *resultobj = 0;
28563 bool arg1 ;
28564 bool val1 ;
28565 int ecode1 = 0 ;
28566 PyObject * obj0 = 0 ;
28567 char * kwnames[] = {
28568 (char *) "val", NULL
28569 };
28570
28571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
28572 ecode1 = SWIG_AsVal_bool(obj0, &val1);
28573 if (!SWIG_IsOK(ecode1)) {
28574 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
28575 }
28576 arg1 = static_cast< bool >(val1);
28577 {
28578 PyThreadState* __tstate = wxPyBeginAllowThreads();
28579 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
28580 wxPyEndAllowThreads(__tstate);
28581 if (PyErr_Occurred()) SWIG_fail;
28582 }
28583 resultobj = SWIG_Py_Void();
28584 return resultobj;
28585 fail:
28586 return NULL;
28587 }
28588
28589
28590 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28591 PyObject *resultobj = 0;
28592 long arg1 ;
28593 long val1 ;
28594 int ecode1 = 0 ;
28595 PyObject * obj0 = 0 ;
28596 char * kwnames[] = {
28597 (char *) "val", NULL
28598 };
28599
28600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
28601 ecode1 = SWIG_AsVal_long(obj0, &val1);
28602 if (!SWIG_IsOK(ecode1)) {
28603 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
28604 }
28605 arg1 = static_cast< long >(val1);
28606 {
28607 PyThreadState* __tstate = wxPyBeginAllowThreads();
28608 wxPyApp::SetMacAboutMenuItemId(arg1);
28609 wxPyEndAllowThreads(__tstate);
28610 if (PyErr_Occurred()) SWIG_fail;
28611 }
28612 resultobj = SWIG_Py_Void();
28613 return resultobj;
28614 fail:
28615 return NULL;
28616 }
28617
28618
28619 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28620 PyObject *resultobj = 0;
28621 long arg1 ;
28622 long val1 ;
28623 int ecode1 = 0 ;
28624 PyObject * obj0 = 0 ;
28625 char * kwnames[] = {
28626 (char *) "val", NULL
28627 };
28628
28629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
28630 ecode1 = SWIG_AsVal_long(obj0, &val1);
28631 if (!SWIG_IsOK(ecode1)) {
28632 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
28633 }
28634 arg1 = static_cast< long >(val1);
28635 {
28636 PyThreadState* __tstate = wxPyBeginAllowThreads();
28637 wxPyApp::SetMacPreferencesMenuItemId(arg1);
28638 wxPyEndAllowThreads(__tstate);
28639 if (PyErr_Occurred()) SWIG_fail;
28640 }
28641 resultobj = SWIG_Py_Void();
28642 return resultobj;
28643 fail:
28644 return NULL;
28645 }
28646
28647
28648 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28649 PyObject *resultobj = 0;
28650 long arg1 ;
28651 long val1 ;
28652 int ecode1 = 0 ;
28653 PyObject * obj0 = 0 ;
28654 char * kwnames[] = {
28655 (char *) "val", NULL
28656 };
28657
28658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
28659 ecode1 = SWIG_AsVal_long(obj0, &val1);
28660 if (!SWIG_IsOK(ecode1)) {
28661 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
28662 }
28663 arg1 = static_cast< long >(val1);
28664 {
28665 PyThreadState* __tstate = wxPyBeginAllowThreads();
28666 wxPyApp::SetMacExitMenuItemId(arg1);
28667 wxPyEndAllowThreads(__tstate);
28668 if (PyErr_Occurred()) SWIG_fail;
28669 }
28670 resultobj = SWIG_Py_Void();
28671 return resultobj;
28672 fail:
28673 return NULL;
28674 }
28675
28676
28677 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28678 PyObject *resultobj = 0;
28679 wxString *arg1 = 0 ;
28680 bool temp1 = false ;
28681 PyObject * obj0 = 0 ;
28682 char * kwnames[] = {
28683 (char *) "val", NULL
28684 };
28685
28686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
28687 {
28688 arg1 = wxString_in_helper(obj0);
28689 if (arg1 == NULL) SWIG_fail;
28690 temp1 = true;
28691 }
28692 {
28693 PyThreadState* __tstate = wxPyBeginAllowThreads();
28694 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
28695 wxPyEndAllowThreads(__tstate);
28696 if (PyErr_Occurred()) SWIG_fail;
28697 }
28698 resultobj = SWIG_Py_Void();
28699 {
28700 if (temp1)
28701 delete arg1;
28702 }
28703 return resultobj;
28704 fail:
28705 {
28706 if (temp1)
28707 delete arg1;
28708 }
28709 return NULL;
28710 }
28711
28712
28713 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28714 PyObject *resultobj = 0;
28715 wxPyApp *arg1 = (wxPyApp *) 0 ;
28716 void *argp1 = 0 ;
28717 int res1 = 0 ;
28718 PyObject *swig_obj[1] ;
28719
28720 if (!args) SWIG_fail;
28721 swig_obj[0] = args;
28722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28723 if (!SWIG_IsOK(res1)) {
28724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28725 }
28726 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28727 {
28728 PyThreadState* __tstate = wxPyBeginAllowThreads();
28729 (arg1)->_BootstrapApp();
28730 wxPyEndAllowThreads(__tstate);
28731 if (PyErr_Occurred()) SWIG_fail;
28732 }
28733 resultobj = SWIG_Py_Void();
28734 return resultobj;
28735 fail:
28736 return NULL;
28737 }
28738
28739
28740 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28741 PyObject *resultobj = 0;
28742 int result;
28743
28744 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28745 {
28746 PyThreadState* __tstate = wxPyBeginAllowThreads();
28747 result = (int)wxPyApp_GetComCtl32Version();
28748 wxPyEndAllowThreads(__tstate);
28749 if (PyErr_Occurred()) SWIG_fail;
28750 }
28751 resultobj = SWIG_From_int(static_cast< int >(result));
28752 return resultobj;
28753 fail:
28754 return NULL;
28755 }
28756
28757
28758 SWIGINTERN PyObject *_wrap_PyApp_IsDisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28759 PyObject *resultobj = 0;
28760 bool result;
28761
28762 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsDisplayAvailable",0,0,0)) SWIG_fail;
28763 {
28764 PyThreadState* __tstate = wxPyBeginAllowThreads();
28765 result = (bool)wxPyApp_IsDisplayAvailable();
28766 wxPyEndAllowThreads(__tstate);
28767 if (PyErr_Occurred()) SWIG_fail;
28768 }
28769 {
28770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28771 }
28772 return resultobj;
28773 fail:
28774 return NULL;
28775 }
28776
28777
28778 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28779 PyObject *obj;
28780 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28781 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28782 return SWIG_Py_Void();
28783 }
28784
28785 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28786 return SWIG_Python_InitShadowInstance(args);
28787 }
28788
28789 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28790 PyObject *resultobj = 0;
28791
28792 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28793 {
28794 PyThreadState* __tstate = wxPyBeginAllowThreads();
28795 wxExit();
28796 wxPyEndAllowThreads(__tstate);
28797 if (PyErr_Occurred()) SWIG_fail;
28798 }
28799 resultobj = SWIG_Py_Void();
28800 return resultobj;
28801 fail:
28802 return NULL;
28803 }
28804
28805
28806 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28807 PyObject *resultobj = 0;
28808 bool result;
28809
28810 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28811 {
28812 PyThreadState* __tstate = wxPyBeginAllowThreads();
28813 result = (bool)wxYield();
28814 wxPyEndAllowThreads(__tstate);
28815 if (PyErr_Occurred()) SWIG_fail;
28816 }
28817 {
28818 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28819 }
28820 return resultobj;
28821 fail:
28822 return NULL;
28823 }
28824
28825
28826 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28827 PyObject *resultobj = 0;
28828 bool result;
28829
28830 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28831 {
28832 PyThreadState* __tstate = wxPyBeginAllowThreads();
28833 result = (bool)wxYieldIfNeeded();
28834 wxPyEndAllowThreads(__tstate);
28835 if (PyErr_Occurred()) SWIG_fail;
28836 }
28837 {
28838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28839 }
28840 return resultobj;
28841 fail:
28842 return NULL;
28843 }
28844
28845
28846 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28847 PyObject *resultobj = 0;
28848 wxWindow *arg1 = (wxWindow *) NULL ;
28849 bool arg2 = (bool) false ;
28850 bool result;
28851 void *argp1 = 0 ;
28852 int res1 = 0 ;
28853 bool val2 ;
28854 int ecode2 = 0 ;
28855 PyObject * obj0 = 0 ;
28856 PyObject * obj1 = 0 ;
28857 char * kwnames[] = {
28858 (char *) "win",(char *) "onlyIfNeeded", NULL
28859 };
28860
28861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28862 if (obj0) {
28863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28864 if (!SWIG_IsOK(res1)) {
28865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28866 }
28867 arg1 = reinterpret_cast< wxWindow * >(argp1);
28868 }
28869 if (obj1) {
28870 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28871 if (!SWIG_IsOK(ecode2)) {
28872 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28873 }
28874 arg2 = static_cast< bool >(val2);
28875 }
28876 {
28877 PyThreadState* __tstate = wxPyBeginAllowThreads();
28878 result = (bool)wxSafeYield(arg1,arg2);
28879 wxPyEndAllowThreads(__tstate);
28880 if (PyErr_Occurred()) SWIG_fail;
28881 }
28882 {
28883 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28884 }
28885 return resultobj;
28886 fail:
28887 return NULL;
28888 }
28889
28890
28891 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28892 PyObject *resultobj = 0;
28893
28894 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28895 {
28896 PyThreadState* __tstate = wxPyBeginAllowThreads();
28897 wxWakeUpIdle();
28898 wxPyEndAllowThreads(__tstate);
28899 if (PyErr_Occurred()) SWIG_fail;
28900 }
28901 resultobj = SWIG_Py_Void();
28902 return resultobj;
28903 fail:
28904 return NULL;
28905 }
28906
28907
28908 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28909 PyObject *resultobj = 0;
28910 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28911 wxEvent *arg2 = 0 ;
28912 void *argp1 = 0 ;
28913 int res1 = 0 ;
28914 void *argp2 = 0 ;
28915 int res2 = 0 ;
28916 PyObject * obj0 = 0 ;
28917 PyObject * obj1 = 0 ;
28918 char * kwnames[] = {
28919 (char *) "dest",(char *) "event", NULL
28920 };
28921
28922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28924 if (!SWIG_IsOK(res1)) {
28925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28926 }
28927 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28928 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28929 if (!SWIG_IsOK(res2)) {
28930 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28931 }
28932 if (!argp2) {
28933 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28934 }
28935 arg2 = reinterpret_cast< wxEvent * >(argp2);
28936 {
28937 PyThreadState* __tstate = wxPyBeginAllowThreads();
28938 wxPostEvent(arg1,*arg2);
28939 wxPyEndAllowThreads(__tstate);
28940 if (PyErr_Occurred()) SWIG_fail;
28941 }
28942 resultobj = SWIG_Py_Void();
28943 return resultobj;
28944 fail:
28945 return NULL;
28946 }
28947
28948
28949 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28950 PyObject *resultobj = 0;
28951
28952 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28953 {
28954 PyThreadState* __tstate = wxPyBeginAllowThreads();
28955 wxApp_CleanUp();
28956 wxPyEndAllowThreads(__tstate);
28957 if (PyErr_Occurred()) SWIG_fail;
28958 }
28959 resultobj = SWIG_Py_Void();
28960 return resultobj;
28961 fail:
28962 return NULL;
28963 }
28964
28965
28966 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28967 PyObject *resultobj = 0;
28968 wxPyApp *result = 0 ;
28969
28970 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28971 {
28972 PyThreadState* __tstate = wxPyBeginAllowThreads();
28973 result = (wxPyApp *)wxPyGetApp();
28974 wxPyEndAllowThreads(__tstate);
28975 if (PyErr_Occurred()) SWIG_fail;
28976 }
28977 {
28978 resultobj = wxPyMake_wxObject(result, 0);
28979 }
28980 return resultobj;
28981 fail:
28982 return NULL;
28983 }
28984
28985
28986 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28987 PyObject *resultobj = 0;
28988 char *arg1 = (char *) 0 ;
28989 int res1 ;
28990 char *buf1 = 0 ;
28991 int alloc1 = 0 ;
28992 PyObject * obj0 = 0 ;
28993 char * kwnames[] = {
28994 (char *) "encoding", NULL
28995 };
28996
28997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28998 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
28999 if (!SWIG_IsOK(res1)) {
29000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
29001 }
29002 arg1 = buf1;
29003 {
29004 PyThreadState* __tstate = wxPyBeginAllowThreads();
29005 wxSetDefaultPyEncoding((char const *)arg1);
29006 wxPyEndAllowThreads(__tstate);
29007 if (PyErr_Occurred()) SWIG_fail;
29008 }
29009 resultobj = SWIG_Py_Void();
29010 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
29011 return resultobj;
29012 fail:
29013 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
29014 return NULL;
29015 }
29016
29017
29018 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29019 PyObject *resultobj = 0;
29020 char *result = 0 ;
29021
29022 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
29023 {
29024 PyThreadState* __tstate = wxPyBeginAllowThreads();
29025 result = (char *)wxGetDefaultPyEncoding();
29026 wxPyEndAllowThreads(__tstate);
29027 if (PyErr_Occurred()) SWIG_fail;
29028 }
29029 resultobj = SWIG_FromCharPtr(result);
29030 return resultobj;
29031 fail:
29032 return NULL;
29033 }
29034
29035
29036 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29037 PyObject *resultobj = 0;
29038 wxEventLoop *result = 0 ;
29039
29040 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
29041 {
29042 PyThreadState* __tstate = wxPyBeginAllowThreads();
29043 result = (wxEventLoop *)new wxEventLoop();
29044 wxPyEndAllowThreads(__tstate);
29045 if (PyErr_Occurred()) SWIG_fail;
29046 }
29047 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
29048 return resultobj;
29049 fail:
29050 return NULL;
29051 }
29052
29053
29054 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29055 PyObject *resultobj = 0;
29056 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29057 void *argp1 = 0 ;
29058 int res1 = 0 ;
29059 PyObject *swig_obj[1] ;
29060
29061 if (!args) SWIG_fail;
29062 swig_obj[0] = args;
29063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
29064 if (!SWIG_IsOK(res1)) {
29065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29066 }
29067 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29068 {
29069 PyThreadState* __tstate = wxPyBeginAllowThreads();
29070 delete arg1;
29071
29072 wxPyEndAllowThreads(__tstate);
29073 if (PyErr_Occurred()) SWIG_fail;
29074 }
29075 resultobj = SWIG_Py_Void();
29076 return resultobj;
29077 fail:
29078 return NULL;
29079 }
29080
29081
29082 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29083 PyObject *resultobj = 0;
29084 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29085 int result;
29086 void *argp1 = 0 ;
29087 int res1 = 0 ;
29088 PyObject *swig_obj[1] ;
29089
29090 if (!args) SWIG_fail;
29091 swig_obj[0] = args;
29092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29093 if (!SWIG_IsOK(res1)) {
29094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29095 }
29096 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29097 {
29098 PyThreadState* __tstate = wxPyBeginAllowThreads();
29099 result = (int)(arg1)->Run();
29100 wxPyEndAllowThreads(__tstate);
29101 if (PyErr_Occurred()) SWIG_fail;
29102 }
29103 resultobj = SWIG_From_int(static_cast< int >(result));
29104 return resultobj;
29105 fail:
29106 return NULL;
29107 }
29108
29109
29110 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29111 PyObject *resultobj = 0;
29112 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29113 int arg2 = (int) 0 ;
29114 void *argp1 = 0 ;
29115 int res1 = 0 ;
29116 int val2 ;
29117 int ecode2 = 0 ;
29118 PyObject * obj0 = 0 ;
29119 PyObject * obj1 = 0 ;
29120 char * kwnames[] = {
29121 (char *) "self",(char *) "rc", NULL
29122 };
29123
29124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
29125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29126 if (!SWIG_IsOK(res1)) {
29127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29128 }
29129 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29130 if (obj1) {
29131 ecode2 = SWIG_AsVal_int(obj1, &val2);
29132 if (!SWIG_IsOK(ecode2)) {
29133 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
29134 }
29135 arg2 = static_cast< int >(val2);
29136 }
29137 {
29138 PyThreadState* __tstate = wxPyBeginAllowThreads();
29139 (arg1)->Exit(arg2);
29140 wxPyEndAllowThreads(__tstate);
29141 if (PyErr_Occurred()) SWIG_fail;
29142 }
29143 resultobj = SWIG_Py_Void();
29144 return resultobj;
29145 fail:
29146 return NULL;
29147 }
29148
29149
29150 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29151 PyObject *resultobj = 0;
29152 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29153 bool result;
29154 void *argp1 = 0 ;
29155 int res1 = 0 ;
29156 PyObject *swig_obj[1] ;
29157
29158 if (!args) SWIG_fail;
29159 swig_obj[0] = args;
29160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29161 if (!SWIG_IsOK(res1)) {
29162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
29163 }
29164 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29165 {
29166 PyThreadState* __tstate = wxPyBeginAllowThreads();
29167 result = (bool)((wxEventLoop const *)arg1)->Pending();
29168 wxPyEndAllowThreads(__tstate);
29169 if (PyErr_Occurred()) SWIG_fail;
29170 }
29171 {
29172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29173 }
29174 return resultobj;
29175 fail:
29176 return NULL;
29177 }
29178
29179
29180 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29181 PyObject *resultobj = 0;
29182 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29183 bool result;
29184 void *argp1 = 0 ;
29185 int res1 = 0 ;
29186 PyObject *swig_obj[1] ;
29187
29188 if (!args) SWIG_fail;
29189 swig_obj[0] = args;
29190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29191 if (!SWIG_IsOK(res1)) {
29192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29193 }
29194 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29195 {
29196 PyThreadState* __tstate = wxPyBeginAllowThreads();
29197 result = (bool)(arg1)->Dispatch();
29198 wxPyEndAllowThreads(__tstate);
29199 if (PyErr_Occurred()) SWIG_fail;
29200 }
29201 {
29202 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29203 }
29204 return resultobj;
29205 fail:
29206 return NULL;
29207 }
29208
29209
29210 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29211 PyObject *resultobj = 0;
29212 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29213 bool result;
29214 void *argp1 = 0 ;
29215 int res1 = 0 ;
29216 PyObject *swig_obj[1] ;
29217
29218 if (!args) SWIG_fail;
29219 swig_obj[0] = args;
29220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29221 if (!SWIG_IsOK(res1)) {
29222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
29223 }
29224 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29225 {
29226 PyThreadState* __tstate = wxPyBeginAllowThreads();
29227 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
29228 wxPyEndAllowThreads(__tstate);
29229 if (PyErr_Occurred()) SWIG_fail;
29230 }
29231 {
29232 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29233 }
29234 return resultobj;
29235 fail:
29236 return NULL;
29237 }
29238
29239
29240 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29241 PyObject *resultobj = 0;
29242 wxEventLoop *result = 0 ;
29243
29244 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
29245 {
29246 PyThreadState* __tstate = wxPyBeginAllowThreads();
29247 result = (wxEventLoop *)wxEventLoop::GetActive();
29248 wxPyEndAllowThreads(__tstate);
29249 if (PyErr_Occurred()) SWIG_fail;
29250 }
29251 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
29252 return resultobj;
29253 fail:
29254 return NULL;
29255 }
29256
29257
29258 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29259 PyObject *resultobj = 0;
29260 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29261 void *argp1 = 0 ;
29262 int res1 = 0 ;
29263 PyObject * obj0 = 0 ;
29264 char * kwnames[] = {
29265 (char *) "loop", NULL
29266 };
29267
29268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
29269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29270 if (!SWIG_IsOK(res1)) {
29271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29272 }
29273 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29274 {
29275 PyThreadState* __tstate = wxPyBeginAllowThreads();
29276 wxEventLoop::SetActive(arg1);
29277 wxPyEndAllowThreads(__tstate);
29278 if (PyErr_Occurred()) SWIG_fail;
29279 }
29280 resultobj = SWIG_Py_Void();
29281 return resultobj;
29282 fail:
29283 return NULL;
29284 }
29285
29286
29287 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29288 PyObject *obj;
29289 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29290 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
29291 return SWIG_Py_Void();
29292 }
29293
29294 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29295 return SWIG_Python_InitShadowInstance(args);
29296 }
29297
29298 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29299 PyObject *resultobj = 0;
29300 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29301 wxEventLoopActivator *result = 0 ;
29302 void *argp1 = 0 ;
29303 int res1 = 0 ;
29304 PyObject * obj0 = 0 ;
29305 char * kwnames[] = {
29306 (char *) "evtLoop", NULL
29307 };
29308
29309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
29310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29311 if (!SWIG_IsOK(res1)) {
29312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29313 }
29314 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29315 {
29316 PyThreadState* __tstate = wxPyBeginAllowThreads();
29317 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
29318 wxPyEndAllowThreads(__tstate);
29319 if (PyErr_Occurred()) SWIG_fail;
29320 }
29321 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
29322 return resultobj;
29323 fail:
29324 return NULL;
29325 }
29326
29327
29328 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29329 PyObject *resultobj = 0;
29330 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
29331 void *argp1 = 0 ;
29332 int res1 = 0 ;
29333 PyObject *swig_obj[1] ;
29334
29335 if (!args) SWIG_fail;
29336 swig_obj[0] = args;
29337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
29338 if (!SWIG_IsOK(res1)) {
29339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
29340 }
29341 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
29342 {
29343 PyThreadState* __tstate = wxPyBeginAllowThreads();
29344 delete arg1;
29345
29346 wxPyEndAllowThreads(__tstate);
29347 if (PyErr_Occurred()) SWIG_fail;
29348 }
29349 resultobj = SWIG_Py_Void();
29350 return resultobj;
29351 fail:
29352 return NULL;
29353 }
29354
29355
29356 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29357 PyObject *obj;
29358 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29359 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
29360 return SWIG_Py_Void();
29361 }
29362
29363 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29364 return SWIG_Python_InitShadowInstance(args);
29365 }
29366
29367 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29368 PyObject *resultobj = 0;
29369 int arg1 = (int) 0 ;
29370 int arg2 = (int) 0 ;
29371 int arg3 = (int) 0 ;
29372 wxAcceleratorEntry *result = 0 ;
29373 int val1 ;
29374 int ecode1 = 0 ;
29375 int val2 ;
29376 int ecode2 = 0 ;
29377 int val3 ;
29378 int ecode3 = 0 ;
29379 PyObject * obj0 = 0 ;
29380 PyObject * obj1 = 0 ;
29381 PyObject * obj2 = 0 ;
29382 char * kwnames[] = {
29383 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
29384 };
29385
29386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29387 if (obj0) {
29388 ecode1 = SWIG_AsVal_int(obj0, &val1);
29389 if (!SWIG_IsOK(ecode1)) {
29390 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
29391 }
29392 arg1 = static_cast< int >(val1);
29393 }
29394 if (obj1) {
29395 ecode2 = SWIG_AsVal_int(obj1, &val2);
29396 if (!SWIG_IsOK(ecode2)) {
29397 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
29398 }
29399 arg2 = static_cast< int >(val2);
29400 }
29401 if (obj2) {
29402 ecode3 = SWIG_AsVal_int(obj2, &val3);
29403 if (!SWIG_IsOK(ecode3)) {
29404 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
29405 }
29406 arg3 = static_cast< int >(val3);
29407 }
29408 {
29409 PyThreadState* __tstate = wxPyBeginAllowThreads();
29410 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
29411 wxPyEndAllowThreads(__tstate);
29412 if (PyErr_Occurred()) SWIG_fail;
29413 }
29414 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
29415 return resultobj;
29416 fail:
29417 return NULL;
29418 }
29419
29420
29421 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29422 PyObject *resultobj = 0;
29423 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29424 void *argp1 = 0 ;
29425 int res1 = 0 ;
29426 PyObject *swig_obj[1] ;
29427
29428 if (!args) SWIG_fail;
29429 swig_obj[0] = args;
29430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
29431 if (!SWIG_IsOK(res1)) {
29432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29433 }
29434 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29435 {
29436 PyThreadState* __tstate = wxPyBeginAllowThreads();
29437 delete arg1;
29438
29439 wxPyEndAllowThreads(__tstate);
29440 if (PyErr_Occurred()) SWIG_fail;
29441 }
29442 resultobj = SWIG_Py_Void();
29443 return resultobj;
29444 fail:
29445 return NULL;
29446 }
29447
29448
29449 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29450 PyObject *resultobj = 0;
29451 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29452 int arg2 ;
29453 int arg3 ;
29454 int arg4 ;
29455 void *argp1 = 0 ;
29456 int res1 = 0 ;
29457 int val2 ;
29458 int ecode2 = 0 ;
29459 int val3 ;
29460 int ecode3 = 0 ;
29461 int val4 ;
29462 int ecode4 = 0 ;
29463 PyObject * obj0 = 0 ;
29464 PyObject * obj1 = 0 ;
29465 PyObject * obj2 = 0 ;
29466 PyObject * obj3 = 0 ;
29467 char * kwnames[] = {
29468 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
29469 };
29470
29471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29473 if (!SWIG_IsOK(res1)) {
29474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29475 }
29476 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29477 ecode2 = SWIG_AsVal_int(obj1, &val2);
29478 if (!SWIG_IsOK(ecode2)) {
29479 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
29480 }
29481 arg2 = static_cast< int >(val2);
29482 ecode3 = SWIG_AsVal_int(obj2, &val3);
29483 if (!SWIG_IsOK(ecode3)) {
29484 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
29485 }
29486 arg3 = static_cast< int >(val3);
29487 ecode4 = SWIG_AsVal_int(obj3, &val4);
29488 if (!SWIG_IsOK(ecode4)) {
29489 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
29490 }
29491 arg4 = static_cast< int >(val4);
29492 {
29493 PyThreadState* __tstate = wxPyBeginAllowThreads();
29494 (arg1)->Set(arg2,arg3,arg4);
29495 wxPyEndAllowThreads(__tstate);
29496 if (PyErr_Occurred()) SWIG_fail;
29497 }
29498 resultobj = SWIG_Py_Void();
29499 return resultobj;
29500 fail:
29501 return NULL;
29502 }
29503
29504
29505 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29506 PyObject *resultobj = 0;
29507 wxString *arg1 = 0 ;
29508 wxAcceleratorEntry *result = 0 ;
29509 bool temp1 = false ;
29510 PyObject * obj0 = 0 ;
29511 char * kwnames[] = {
29512 (char *) "str", NULL
29513 };
29514
29515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_Create",kwnames,&obj0)) SWIG_fail;
29516 {
29517 arg1 = wxString_in_helper(obj0);
29518 if (arg1 == NULL) SWIG_fail;
29519 temp1 = true;
29520 }
29521 {
29522 PyThreadState* __tstate = wxPyBeginAllowThreads();
29523 result = (wxAcceleratorEntry *)wxAcceleratorEntry::Create((wxString const &)*arg1);
29524 wxPyEndAllowThreads(__tstate);
29525 if (PyErr_Occurred()) SWIG_fail;
29526 }
29527 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_OWN | 0 );
29528 {
29529 if (temp1)
29530 delete arg1;
29531 }
29532 return resultobj;
29533 fail:
29534 {
29535 if (temp1)
29536 delete arg1;
29537 }
29538 return NULL;
29539 }
29540
29541
29542 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29543 PyObject *resultobj = 0;
29544 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29545 int result;
29546 void *argp1 = 0 ;
29547 int res1 = 0 ;
29548 PyObject *swig_obj[1] ;
29549
29550 if (!args) SWIG_fail;
29551 swig_obj[0] = args;
29552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29553 if (!SWIG_IsOK(res1)) {
29554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29555 }
29556 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29557 {
29558 PyThreadState* __tstate = wxPyBeginAllowThreads();
29559 result = (int)(arg1)->GetFlags();
29560 wxPyEndAllowThreads(__tstate);
29561 if (PyErr_Occurred()) SWIG_fail;
29562 }
29563 resultobj = SWIG_From_int(static_cast< int >(result));
29564 return resultobj;
29565 fail:
29566 return NULL;
29567 }
29568
29569
29570 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29571 PyObject *resultobj = 0;
29572 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29573 int result;
29574 void *argp1 = 0 ;
29575 int res1 = 0 ;
29576 PyObject *swig_obj[1] ;
29577
29578 if (!args) SWIG_fail;
29579 swig_obj[0] = args;
29580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29581 if (!SWIG_IsOK(res1)) {
29582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29583 }
29584 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29585 {
29586 PyThreadState* __tstate = wxPyBeginAllowThreads();
29587 result = (int)(arg1)->GetKeyCode();
29588 wxPyEndAllowThreads(__tstate);
29589 if (PyErr_Occurred()) SWIG_fail;
29590 }
29591 resultobj = SWIG_From_int(static_cast< int >(result));
29592 return resultobj;
29593 fail:
29594 return NULL;
29595 }
29596
29597
29598 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29599 PyObject *resultobj = 0;
29600 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29601 int result;
29602 void *argp1 = 0 ;
29603 int res1 = 0 ;
29604 PyObject *swig_obj[1] ;
29605
29606 if (!args) SWIG_fail;
29607 swig_obj[0] = args;
29608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29609 if (!SWIG_IsOK(res1)) {
29610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29611 }
29612 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29613 {
29614 PyThreadState* __tstate = wxPyBeginAllowThreads();
29615 result = (int)(arg1)->GetCommand();
29616 wxPyEndAllowThreads(__tstate);
29617 if (PyErr_Occurred()) SWIG_fail;
29618 }
29619 resultobj = SWIG_From_int(static_cast< int >(result));
29620 return resultobj;
29621 fail:
29622 return NULL;
29623 }
29624
29625
29626 SWIGINTERN PyObject *_wrap_AcceleratorEntry_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29627 PyObject *resultobj = 0;
29628 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29629 bool result;
29630 void *argp1 = 0 ;
29631 int res1 = 0 ;
29632 PyObject *swig_obj[1] ;
29633
29634 if (!args) SWIG_fail;
29635 swig_obj[0] = args;
29636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29637 if (!SWIG_IsOK(res1)) {
29638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
29639 }
29640 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29641 {
29642 PyThreadState* __tstate = wxPyBeginAllowThreads();
29643 result = (bool)((wxAcceleratorEntry const *)arg1)->IsOk();
29644 wxPyEndAllowThreads(__tstate);
29645 if (PyErr_Occurred()) SWIG_fail;
29646 }
29647 {
29648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29649 }
29650 return resultobj;
29651 fail:
29652 return NULL;
29653 }
29654
29655
29656 SWIGINTERN PyObject *_wrap_AcceleratorEntry_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29657 PyObject *resultobj = 0;
29658 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29659 wxString result;
29660 void *argp1 = 0 ;
29661 int res1 = 0 ;
29662 PyObject *swig_obj[1] ;
29663
29664 if (!args) SWIG_fail;
29665 swig_obj[0] = args;
29666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29667 if (!SWIG_IsOK(res1)) {
29668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_ToString" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
29669 }
29670 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29671 {
29672 PyThreadState* __tstate = wxPyBeginAllowThreads();
29673 result = ((wxAcceleratorEntry const *)arg1)->ToString();
29674 wxPyEndAllowThreads(__tstate);
29675 if (PyErr_Occurred()) SWIG_fail;
29676 }
29677 {
29678 #if wxUSE_UNICODE
29679 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29680 #else
29681 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29682 #endif
29683 }
29684 return resultobj;
29685 fail:
29686 return NULL;
29687 }
29688
29689
29690 SWIGINTERN PyObject *_wrap_AcceleratorEntry_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29691 PyObject *resultobj = 0;
29692 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29693 wxString *arg2 = 0 ;
29694 bool result;
29695 void *argp1 = 0 ;
29696 int res1 = 0 ;
29697 bool temp2 = false ;
29698 PyObject * obj0 = 0 ;
29699 PyObject * obj1 = 0 ;
29700 char * kwnames[] = {
29701 (char *) "self",(char *) "str", NULL
29702 };
29703
29704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AcceleratorEntry_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
29705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29706 if (!SWIG_IsOK(res1)) {
29707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_FromString" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29708 }
29709 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29710 {
29711 arg2 = wxString_in_helper(obj1);
29712 if (arg2 == NULL) SWIG_fail;
29713 temp2 = true;
29714 }
29715 {
29716 PyThreadState* __tstate = wxPyBeginAllowThreads();
29717 result = (bool)(arg1)->FromString((wxString const &)*arg2);
29718 wxPyEndAllowThreads(__tstate);
29719 if (PyErr_Occurred()) SWIG_fail;
29720 }
29721 {
29722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29723 }
29724 {
29725 if (temp2)
29726 delete arg2;
29727 }
29728 return resultobj;
29729 fail:
29730 {
29731 if (temp2)
29732 delete arg2;
29733 }
29734 return NULL;
29735 }
29736
29737
29738 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29739 PyObject *obj;
29740 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29741 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
29742 return SWIG_Py_Void();
29743 }
29744
29745 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29746 return SWIG_Python_InitShadowInstance(args);
29747 }
29748
29749 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29750 PyObject *resultobj = 0;
29751 int arg1 ;
29752 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
29753 wxAcceleratorTable *result = 0 ;
29754 PyObject * obj0 = 0 ;
29755 char * kwnames[] = {
29756 (char *) "n", NULL
29757 };
29758
29759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
29760 {
29761 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
29762 if (arg2) arg1 = PyList_Size(obj0);
29763 else arg1 = 0;
29764 }
29765 {
29766 PyThreadState* __tstate = wxPyBeginAllowThreads();
29767 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
29768 wxPyEndAllowThreads(__tstate);
29769 if (PyErr_Occurred()) SWIG_fail;
29770 }
29771 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
29772 return resultobj;
29773 fail:
29774 return NULL;
29775 }
29776
29777
29778 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29779 PyObject *resultobj = 0;
29780 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29781 void *argp1 = 0 ;
29782 int res1 = 0 ;
29783 PyObject *swig_obj[1] ;
29784
29785 if (!args) SWIG_fail;
29786 swig_obj[0] = args;
29787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
29788 if (!SWIG_IsOK(res1)) {
29789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
29790 }
29791 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29792 {
29793 PyThreadState* __tstate = wxPyBeginAllowThreads();
29794 delete arg1;
29795
29796 wxPyEndAllowThreads(__tstate);
29797 if (PyErr_Occurred()) SWIG_fail;
29798 }
29799 resultobj = SWIG_Py_Void();
29800 return resultobj;
29801 fail:
29802 return NULL;
29803 }
29804
29805
29806 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29807 PyObject *resultobj = 0;
29808 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29809 bool result;
29810 void *argp1 = 0 ;
29811 int res1 = 0 ;
29812 PyObject *swig_obj[1] ;
29813
29814 if (!args) SWIG_fail;
29815 swig_obj[0] = args;
29816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
29817 if (!SWIG_IsOK(res1)) {
29818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
29819 }
29820 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29821 {
29822 PyThreadState* __tstate = wxPyBeginAllowThreads();
29823 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
29824 wxPyEndAllowThreads(__tstate);
29825 if (PyErr_Occurred()) SWIG_fail;
29826 }
29827 {
29828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29829 }
29830 return resultobj;
29831 fail:
29832 return NULL;
29833 }
29834
29835
29836 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29837 PyObject *obj;
29838 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29839 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
29840 return SWIG_Py_Void();
29841 }
29842
29843 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29844 return SWIG_Python_InitShadowInstance(args);
29845 }
29846
29847 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
29848 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
29849 return 1;
29850 }
29851
29852
29853 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
29854 PyObject *pyobj = 0;
29855
29856 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
29857 return pyobj;
29858 }
29859
29860
29861 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29862 PyObject *resultobj = 0;
29863 wxString *arg1 = 0 ;
29864 wxAcceleratorEntry *result = 0 ;
29865 bool temp1 = false ;
29866 PyObject * obj0 = 0 ;
29867 char * kwnames[] = {
29868 (char *) "label", NULL
29869 };
29870
29871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
29872 {
29873 arg1 = wxString_in_helper(obj0);
29874 if (arg1 == NULL) SWIG_fail;
29875 temp1 = true;
29876 }
29877 {
29878 PyThreadState* __tstate = wxPyBeginAllowThreads();
29879 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29880 wxPyEndAllowThreads(__tstate);
29881 if (PyErr_Occurred()) SWIG_fail;
29882 }
29883 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29884 {
29885 if (temp1)
29886 delete arg1;
29887 }
29888 return resultobj;
29889 fail:
29890 {
29891 if (temp1)
29892 delete arg1;
29893 }
29894 return NULL;
29895 }
29896
29897
29898 SWIGINTERN int PanelNameStr_set(PyObject *) {
29899 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29900 return 1;
29901 }
29902
29903
29904 SWIGINTERN PyObject *PanelNameStr_get(void) {
29905 PyObject *pyobj = 0;
29906
29907 {
29908 #if wxUSE_UNICODE
29909 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29910 #else
29911 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29912 #endif
29913 }
29914 return pyobj;
29915 }
29916
29917
29918 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29919 PyObject *resultobj = 0;
29920 wxVisualAttributes *result = 0 ;
29921
29922 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29923 {
29924 PyThreadState* __tstate = wxPyBeginAllowThreads();
29925 result = (wxVisualAttributes *)new_wxVisualAttributes();
29926 wxPyEndAllowThreads(__tstate);
29927 if (PyErr_Occurred()) SWIG_fail;
29928 }
29929 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29930 return resultobj;
29931 fail:
29932 return NULL;
29933 }
29934
29935
29936 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29937 PyObject *resultobj = 0;
29938 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29939 void *argp1 = 0 ;
29940 int res1 = 0 ;
29941 PyObject *swig_obj[1] ;
29942
29943 if (!args) SWIG_fail;
29944 swig_obj[0] = args;
29945 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29946 if (!SWIG_IsOK(res1)) {
29947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29948 }
29949 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29950 {
29951 PyThreadState* __tstate = wxPyBeginAllowThreads();
29952 delete_wxVisualAttributes(arg1);
29953
29954 wxPyEndAllowThreads(__tstate);
29955 if (PyErr_Occurred()) SWIG_fail;
29956 }
29957 resultobj = SWIG_Py_Void();
29958 return resultobj;
29959 fail:
29960 return NULL;
29961 }
29962
29963
29964 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29965 PyObject *resultobj = 0;
29966 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29967 wxFont *arg2 = (wxFont *) 0 ;
29968 void *argp1 = 0 ;
29969 int res1 = 0 ;
29970 void *argp2 = 0 ;
29971 int res2 = 0 ;
29972 PyObject *swig_obj[2] ;
29973
29974 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29976 if (!SWIG_IsOK(res1)) {
29977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29978 }
29979 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29980 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29981 if (!SWIG_IsOK(res2)) {
29982 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29983 }
29984 arg2 = reinterpret_cast< wxFont * >(argp2);
29985 if (arg1) (arg1)->font = *arg2;
29986
29987 resultobj = SWIG_Py_Void();
29988 return resultobj;
29989 fail:
29990 return NULL;
29991 }
29992
29993
29994 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29995 PyObject *resultobj = 0;
29996 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29997 wxFont *result = 0 ;
29998 void *argp1 = 0 ;
29999 int res1 = 0 ;
30000 PyObject *swig_obj[1] ;
30001
30002 if (!args) SWIG_fail;
30003 swig_obj[0] = args;
30004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30005 if (!SWIG_IsOK(res1)) {
30006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30007 }
30008 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30009 result = (wxFont *)& ((arg1)->font);
30010 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
30011 return resultobj;
30012 fail:
30013 return NULL;
30014 }
30015
30016
30017 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30018 PyObject *resultobj = 0;
30019 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30020 wxColour *arg2 = (wxColour *) 0 ;
30021 void *argp1 = 0 ;
30022 int res1 = 0 ;
30023 void *argp2 = 0 ;
30024 int res2 = 0 ;
30025 PyObject *swig_obj[2] ;
30026
30027 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
30028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30029 if (!SWIG_IsOK(res1)) {
30030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30031 }
30032 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30033 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
30034 if (!SWIG_IsOK(res2)) {
30035 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
30036 }
30037 arg2 = reinterpret_cast< wxColour * >(argp2);
30038 if (arg1) (arg1)->colFg = *arg2;
30039
30040 resultobj = SWIG_Py_Void();
30041 return resultobj;
30042 fail:
30043 return NULL;
30044 }
30045
30046
30047 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30048 PyObject *resultobj = 0;
30049 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30050 wxColour *result = 0 ;
30051 void *argp1 = 0 ;
30052 int res1 = 0 ;
30053 PyObject *swig_obj[1] ;
30054
30055 if (!args) SWIG_fail;
30056 swig_obj[0] = args;
30057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30058 if (!SWIG_IsOK(res1)) {
30059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30060 }
30061 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30062 result = (wxColour *)& ((arg1)->colFg);
30063 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
30064 return resultobj;
30065 fail:
30066 return NULL;
30067 }
30068
30069
30070 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30071 PyObject *resultobj = 0;
30072 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30073 wxColour *arg2 = (wxColour *) 0 ;
30074 void *argp1 = 0 ;
30075 int res1 = 0 ;
30076 void *argp2 = 0 ;
30077 int res2 = 0 ;
30078 PyObject *swig_obj[2] ;
30079
30080 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
30081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30082 if (!SWIG_IsOK(res1)) {
30083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30084 }
30085 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30086 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
30087 if (!SWIG_IsOK(res2)) {
30088 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
30089 }
30090 arg2 = reinterpret_cast< wxColour * >(argp2);
30091 if (arg1) (arg1)->colBg = *arg2;
30092
30093 resultobj = SWIG_Py_Void();
30094 return resultobj;
30095 fail:
30096 return NULL;
30097 }
30098
30099
30100 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30101 PyObject *resultobj = 0;
30102 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
30103 wxColour *result = 0 ;
30104 void *argp1 = 0 ;
30105 int res1 = 0 ;
30106 PyObject *swig_obj[1] ;
30107
30108 if (!args) SWIG_fail;
30109 swig_obj[0] = args;
30110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
30111 if (!SWIG_IsOK(res1)) {
30112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
30113 }
30114 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
30115 result = (wxColour *)& ((arg1)->colBg);
30116 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
30117 return resultobj;
30118 fail:
30119 return NULL;
30120 }
30121
30122
30123 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30124 PyObject *obj;
30125 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30126 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
30127 return SWIG_Py_Void();
30128 }
30129
30130 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30131 return SWIG_Python_InitShadowInstance(args);
30132 }
30133
30134 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30135 PyObject *resultobj = 0;
30136 wxWindow *arg1 = (wxWindow *) 0 ;
30137 int arg2 = (int) (int)-1 ;
30138 wxPoint const &arg3_defvalue = wxDefaultPosition ;
30139 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
30140 wxSize const &arg4_defvalue = wxDefaultSize ;
30141 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
30142 long arg5 = (long) 0 ;
30143 wxString const &arg6_defvalue = wxPyPanelNameStr ;
30144 wxString *arg6 = (wxString *) &arg6_defvalue ;
30145 wxWindow *result = 0 ;
30146 void *argp1 = 0 ;
30147 int res1 = 0 ;
30148 int val2 ;
30149 int ecode2 = 0 ;
30150 wxPoint temp3 ;
30151 wxSize temp4 ;
30152 long val5 ;
30153 int ecode5 = 0 ;
30154 bool temp6 = false ;
30155 PyObject * obj0 = 0 ;
30156 PyObject * obj1 = 0 ;
30157 PyObject * obj2 = 0 ;
30158 PyObject * obj3 = 0 ;
30159 PyObject * obj4 = 0 ;
30160 PyObject * obj5 = 0 ;
30161 char * kwnames[] = {
30162 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
30163 };
30164
30165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30167 if (!SWIG_IsOK(res1)) {
30168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
30169 }
30170 arg1 = reinterpret_cast< wxWindow * >(argp1);
30171 if (obj1) {
30172 ecode2 = SWIG_AsVal_int(obj1, &val2);
30173 if (!SWIG_IsOK(ecode2)) {
30174 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
30175 }
30176 arg2 = static_cast< int >(val2);
30177 }
30178 if (obj2) {
30179 {
30180 arg3 = &temp3;
30181 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30182 }
30183 }
30184 if (obj3) {
30185 {
30186 arg4 = &temp4;
30187 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
30188 }
30189 }
30190 if (obj4) {
30191 ecode5 = SWIG_AsVal_long(obj4, &val5);
30192 if (!SWIG_IsOK(ecode5)) {
30193 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
30194 }
30195 arg5 = static_cast< long >(val5);
30196 }
30197 if (obj5) {
30198 {
30199 arg6 = wxString_in_helper(obj5);
30200 if (arg6 == NULL) SWIG_fail;
30201 temp6 = true;
30202 }
30203 }
30204 {
30205 if (!wxPyCheckForApp()) SWIG_fail;
30206 PyThreadState* __tstate = wxPyBeginAllowThreads();
30207 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
30208 wxPyEndAllowThreads(__tstate);
30209 if (PyErr_Occurred()) SWIG_fail;
30210 }
30211 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
30212 {
30213 if (temp6)
30214 delete arg6;
30215 }
30216 return resultobj;
30217 fail:
30218 {
30219 if (temp6)
30220 delete arg6;
30221 }
30222 return NULL;
30223 }
30224
30225
30226 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30227 PyObject *resultobj = 0;
30228 wxWindow *result = 0 ;
30229
30230 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
30231 {
30232 if (!wxPyCheckForApp()) SWIG_fail;
30233 PyThreadState* __tstate = wxPyBeginAllowThreads();
30234 result = (wxWindow *)new wxWindow();
30235 wxPyEndAllowThreads(__tstate);
30236 if (PyErr_Occurred()) SWIG_fail;
30237 }
30238 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
30239 return resultobj;
30240 fail:
30241 return NULL;
30242 }
30243
30244
30245 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30246 PyObject *resultobj = 0;
30247 wxWindow *arg1 = (wxWindow *) 0 ;
30248 wxWindow *arg2 = (wxWindow *) 0 ;
30249 int arg3 = (int) (int)-1 ;
30250 wxPoint const &arg4_defvalue = wxDefaultPosition ;
30251 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
30252 wxSize const &arg5_defvalue = wxDefaultSize ;
30253 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
30254 long arg6 = (long) 0 ;
30255 wxString const &arg7_defvalue = wxPyPanelNameStr ;
30256 wxString *arg7 = (wxString *) &arg7_defvalue ;
30257 bool result;
30258 void *argp1 = 0 ;
30259 int res1 = 0 ;
30260 void *argp2 = 0 ;
30261 int res2 = 0 ;
30262 int val3 ;
30263 int ecode3 = 0 ;
30264 wxPoint temp4 ;
30265 wxSize temp5 ;
30266 long val6 ;
30267 int ecode6 = 0 ;
30268 bool temp7 = false ;
30269 PyObject * obj0 = 0 ;
30270 PyObject * obj1 = 0 ;
30271 PyObject * obj2 = 0 ;
30272 PyObject * obj3 = 0 ;
30273 PyObject * obj4 = 0 ;
30274 PyObject * obj5 = 0 ;
30275 PyObject * obj6 = 0 ;
30276 char * kwnames[] = {
30277 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
30278 };
30279
30280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
30281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30282 if (!SWIG_IsOK(res1)) {
30283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
30284 }
30285 arg1 = reinterpret_cast< wxWindow * >(argp1);
30286 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30287 if (!SWIG_IsOK(res2)) {
30288 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
30289 }
30290 arg2 = reinterpret_cast< wxWindow * >(argp2);
30291 if (obj2) {
30292 ecode3 = SWIG_AsVal_int(obj2, &val3);
30293 if (!SWIG_IsOK(ecode3)) {
30294 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
30295 }
30296 arg3 = static_cast< int >(val3);
30297 }
30298 if (obj3) {
30299 {
30300 arg4 = &temp4;
30301 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
30302 }
30303 }
30304 if (obj4) {
30305 {
30306 arg5 = &temp5;
30307 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
30308 }
30309 }
30310 if (obj5) {
30311 ecode6 = SWIG_AsVal_long(obj5, &val6);
30312 if (!SWIG_IsOK(ecode6)) {
30313 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
30314 }
30315 arg6 = static_cast< long >(val6);
30316 }
30317 if (obj6) {
30318 {
30319 arg7 = wxString_in_helper(obj6);
30320 if (arg7 == NULL) SWIG_fail;
30321 temp7 = true;
30322 }
30323 }
30324 {
30325 PyThreadState* __tstate = wxPyBeginAllowThreads();
30326 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
30327 wxPyEndAllowThreads(__tstate);
30328 if (PyErr_Occurred()) SWIG_fail;
30329 }
30330 {
30331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30332 }
30333 {
30334 if (temp7)
30335 delete arg7;
30336 }
30337 return resultobj;
30338 fail:
30339 {
30340 if (temp7)
30341 delete arg7;
30342 }
30343 return NULL;
30344 }
30345
30346
30347 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30348 PyObject *resultobj = 0;
30349 wxWindow *arg1 = (wxWindow *) 0 ;
30350 bool arg2 = (bool) false ;
30351 bool result;
30352 void *argp1 = 0 ;
30353 int res1 = 0 ;
30354 bool val2 ;
30355 int ecode2 = 0 ;
30356 PyObject * obj0 = 0 ;
30357 PyObject * obj1 = 0 ;
30358 char * kwnames[] = {
30359 (char *) "self",(char *) "force", NULL
30360 };
30361
30362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
30363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30364 if (!SWIG_IsOK(res1)) {
30365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
30366 }
30367 arg1 = reinterpret_cast< wxWindow * >(argp1);
30368 if (obj1) {
30369 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30370 if (!SWIG_IsOK(ecode2)) {
30371 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
30372 }
30373 arg2 = static_cast< bool >(val2);
30374 }
30375 {
30376 PyThreadState* __tstate = wxPyBeginAllowThreads();
30377 result = (bool)(arg1)->Close(arg2);
30378 wxPyEndAllowThreads(__tstate);
30379 if (PyErr_Occurred()) SWIG_fail;
30380 }
30381 {
30382 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30383 }
30384 return resultobj;
30385 fail:
30386 return NULL;
30387 }
30388
30389
30390 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30391 PyObject *resultobj = 0;
30392 wxWindow *arg1 = (wxWindow *) 0 ;
30393 bool result;
30394 void *argp1 = 0 ;
30395 int res1 = 0 ;
30396 PyObject *swig_obj[1] ;
30397
30398 if (!args) SWIG_fail;
30399 swig_obj[0] = args;
30400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30401 if (!SWIG_IsOK(res1)) {
30402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
30403 }
30404 arg1 = reinterpret_cast< wxWindow * >(argp1);
30405 {
30406 PyThreadState* __tstate = wxPyBeginAllowThreads();
30407 result = (bool)(arg1)->Destroy();
30408 wxPyEndAllowThreads(__tstate);
30409 if (PyErr_Occurred()) SWIG_fail;
30410 }
30411 {
30412 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30413 }
30414 return resultobj;
30415 fail:
30416 return NULL;
30417 }
30418
30419
30420 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30421 PyObject *resultobj = 0;
30422 wxWindow *arg1 = (wxWindow *) 0 ;
30423 bool result;
30424 void *argp1 = 0 ;
30425 int res1 = 0 ;
30426 PyObject *swig_obj[1] ;
30427
30428 if (!args) SWIG_fail;
30429 swig_obj[0] = args;
30430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30431 if (!SWIG_IsOK(res1)) {
30432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
30433 }
30434 arg1 = reinterpret_cast< wxWindow * >(argp1);
30435 {
30436 PyThreadState* __tstate = wxPyBeginAllowThreads();
30437 result = (bool)(arg1)->DestroyChildren();
30438 wxPyEndAllowThreads(__tstate);
30439 if (PyErr_Occurred()) SWIG_fail;
30440 }
30441 {
30442 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30443 }
30444 return resultobj;
30445 fail:
30446 return NULL;
30447 }
30448
30449
30450 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30451 PyObject *resultobj = 0;
30452 wxWindow *arg1 = (wxWindow *) 0 ;
30453 bool result;
30454 void *argp1 = 0 ;
30455 int res1 = 0 ;
30456 PyObject *swig_obj[1] ;
30457
30458 if (!args) SWIG_fail;
30459 swig_obj[0] = args;
30460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30461 if (!SWIG_IsOK(res1)) {
30462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
30463 }
30464 arg1 = reinterpret_cast< wxWindow * >(argp1);
30465 {
30466 PyThreadState* __tstate = wxPyBeginAllowThreads();
30467 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
30468 wxPyEndAllowThreads(__tstate);
30469 if (PyErr_Occurred()) SWIG_fail;
30470 }
30471 {
30472 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30473 }
30474 return resultobj;
30475 fail:
30476 return NULL;
30477 }
30478
30479
30480 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30481 PyObject *resultobj = 0;
30482 wxWindow *arg1 = (wxWindow *) 0 ;
30483 wxString *arg2 = 0 ;
30484 void *argp1 = 0 ;
30485 int res1 = 0 ;
30486 bool temp2 = false ;
30487 PyObject * obj0 = 0 ;
30488 PyObject * obj1 = 0 ;
30489 char * kwnames[] = {
30490 (char *) "self",(char *) "label", NULL
30491 };
30492
30493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
30494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30495 if (!SWIG_IsOK(res1)) {
30496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
30497 }
30498 arg1 = reinterpret_cast< wxWindow * >(argp1);
30499 {
30500 arg2 = wxString_in_helper(obj1);
30501 if (arg2 == NULL) SWIG_fail;
30502 temp2 = true;
30503 }
30504 {
30505 PyThreadState* __tstate = wxPyBeginAllowThreads();
30506 (arg1)->SetLabel((wxString const &)*arg2);
30507 wxPyEndAllowThreads(__tstate);
30508 if (PyErr_Occurred()) SWIG_fail;
30509 }
30510 resultobj = SWIG_Py_Void();
30511 {
30512 if (temp2)
30513 delete arg2;
30514 }
30515 return resultobj;
30516 fail:
30517 {
30518 if (temp2)
30519 delete arg2;
30520 }
30521 return NULL;
30522 }
30523
30524
30525 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30526 PyObject *resultobj = 0;
30527 wxWindow *arg1 = (wxWindow *) 0 ;
30528 wxString result;
30529 void *argp1 = 0 ;
30530 int res1 = 0 ;
30531 PyObject *swig_obj[1] ;
30532
30533 if (!args) SWIG_fail;
30534 swig_obj[0] = args;
30535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30536 if (!SWIG_IsOK(res1)) {
30537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
30538 }
30539 arg1 = reinterpret_cast< wxWindow * >(argp1);
30540 {
30541 PyThreadState* __tstate = wxPyBeginAllowThreads();
30542 result = ((wxWindow const *)arg1)->GetLabel();
30543 wxPyEndAllowThreads(__tstate);
30544 if (PyErr_Occurred()) SWIG_fail;
30545 }
30546 {
30547 #if wxUSE_UNICODE
30548 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30549 #else
30550 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30551 #endif
30552 }
30553 return resultobj;
30554 fail:
30555 return NULL;
30556 }
30557
30558
30559 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30560 PyObject *resultobj = 0;
30561 wxWindow *arg1 = (wxWindow *) 0 ;
30562 wxString *arg2 = 0 ;
30563 void *argp1 = 0 ;
30564 int res1 = 0 ;
30565 bool temp2 = false ;
30566 PyObject * obj0 = 0 ;
30567 PyObject * obj1 = 0 ;
30568 char * kwnames[] = {
30569 (char *) "self",(char *) "name", NULL
30570 };
30571
30572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
30573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30574 if (!SWIG_IsOK(res1)) {
30575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
30576 }
30577 arg1 = reinterpret_cast< wxWindow * >(argp1);
30578 {
30579 arg2 = wxString_in_helper(obj1);
30580 if (arg2 == NULL) SWIG_fail;
30581 temp2 = true;
30582 }
30583 {
30584 PyThreadState* __tstate = wxPyBeginAllowThreads();
30585 (arg1)->SetName((wxString const &)*arg2);
30586 wxPyEndAllowThreads(__tstate);
30587 if (PyErr_Occurred()) SWIG_fail;
30588 }
30589 resultobj = SWIG_Py_Void();
30590 {
30591 if (temp2)
30592 delete arg2;
30593 }
30594 return resultobj;
30595 fail:
30596 {
30597 if (temp2)
30598 delete arg2;
30599 }
30600 return NULL;
30601 }
30602
30603
30604 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30605 PyObject *resultobj = 0;
30606 wxWindow *arg1 = (wxWindow *) 0 ;
30607 wxString result;
30608 void *argp1 = 0 ;
30609 int res1 = 0 ;
30610 PyObject *swig_obj[1] ;
30611
30612 if (!args) SWIG_fail;
30613 swig_obj[0] = args;
30614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30615 if (!SWIG_IsOK(res1)) {
30616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
30617 }
30618 arg1 = reinterpret_cast< wxWindow * >(argp1);
30619 {
30620 PyThreadState* __tstate = wxPyBeginAllowThreads();
30621 result = ((wxWindow const *)arg1)->GetName();
30622 wxPyEndAllowThreads(__tstate);
30623 if (PyErr_Occurred()) SWIG_fail;
30624 }
30625 {
30626 #if wxUSE_UNICODE
30627 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30628 #else
30629 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30630 #endif
30631 }
30632 return resultobj;
30633 fail:
30634 return NULL;
30635 }
30636
30637
30638 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30639 PyObject *resultobj = 0;
30640 wxWindow *arg1 = (wxWindow *) 0 ;
30641 wxWindowVariant arg2 ;
30642 void *argp1 = 0 ;
30643 int res1 = 0 ;
30644 int val2 ;
30645 int ecode2 = 0 ;
30646 PyObject * obj0 = 0 ;
30647 PyObject * obj1 = 0 ;
30648 char * kwnames[] = {
30649 (char *) "self",(char *) "variant", NULL
30650 };
30651
30652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
30653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30654 if (!SWIG_IsOK(res1)) {
30655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
30656 }
30657 arg1 = reinterpret_cast< wxWindow * >(argp1);
30658 ecode2 = SWIG_AsVal_int(obj1, &val2);
30659 if (!SWIG_IsOK(ecode2)) {
30660 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
30661 }
30662 arg2 = static_cast< wxWindowVariant >(val2);
30663 {
30664 PyThreadState* __tstate = wxPyBeginAllowThreads();
30665 (arg1)->SetWindowVariant(arg2);
30666 wxPyEndAllowThreads(__tstate);
30667 if (PyErr_Occurred()) SWIG_fail;
30668 }
30669 resultobj = SWIG_Py_Void();
30670 return resultobj;
30671 fail:
30672 return NULL;
30673 }
30674
30675
30676 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30677 PyObject *resultobj = 0;
30678 wxWindow *arg1 = (wxWindow *) 0 ;
30679 wxWindowVariant result;
30680 void *argp1 = 0 ;
30681 int res1 = 0 ;
30682 PyObject *swig_obj[1] ;
30683
30684 if (!args) SWIG_fail;
30685 swig_obj[0] = args;
30686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30687 if (!SWIG_IsOK(res1)) {
30688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
30689 }
30690 arg1 = reinterpret_cast< wxWindow * >(argp1);
30691 {
30692 PyThreadState* __tstate = wxPyBeginAllowThreads();
30693 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
30694 wxPyEndAllowThreads(__tstate);
30695 if (PyErr_Occurred()) SWIG_fail;
30696 }
30697 resultobj = SWIG_From_int(static_cast< int >(result));
30698 return resultobj;
30699 fail:
30700 return NULL;
30701 }
30702
30703
30704 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30705 PyObject *resultobj = 0;
30706 wxWindow *arg1 = (wxWindow *) 0 ;
30707 int arg2 ;
30708 void *argp1 = 0 ;
30709 int res1 = 0 ;
30710 int val2 ;
30711 int ecode2 = 0 ;
30712 PyObject * obj0 = 0 ;
30713 PyObject * obj1 = 0 ;
30714 char * kwnames[] = {
30715 (char *) "self",(char *) "winid", NULL
30716 };
30717
30718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30720 if (!SWIG_IsOK(res1)) {
30721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
30722 }
30723 arg1 = reinterpret_cast< wxWindow * >(argp1);
30724 ecode2 = SWIG_AsVal_int(obj1, &val2);
30725 if (!SWIG_IsOK(ecode2)) {
30726 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
30727 }
30728 arg2 = static_cast< int >(val2);
30729 {
30730 PyThreadState* __tstate = wxPyBeginAllowThreads();
30731 (arg1)->SetId(arg2);
30732 wxPyEndAllowThreads(__tstate);
30733 if (PyErr_Occurred()) SWIG_fail;
30734 }
30735 resultobj = SWIG_Py_Void();
30736 return resultobj;
30737 fail:
30738 return NULL;
30739 }
30740
30741
30742 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30743 PyObject *resultobj = 0;
30744 wxWindow *arg1 = (wxWindow *) 0 ;
30745 int result;
30746 void *argp1 = 0 ;
30747 int res1 = 0 ;
30748 PyObject *swig_obj[1] ;
30749
30750 if (!args) SWIG_fail;
30751 swig_obj[0] = args;
30752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30753 if (!SWIG_IsOK(res1)) {
30754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
30755 }
30756 arg1 = reinterpret_cast< wxWindow * >(argp1);
30757 {
30758 PyThreadState* __tstate = wxPyBeginAllowThreads();
30759 result = (int)((wxWindow const *)arg1)->GetId();
30760 wxPyEndAllowThreads(__tstate);
30761 if (PyErr_Occurred()) SWIG_fail;
30762 }
30763 resultobj = SWIG_From_int(static_cast< int >(result));
30764 return resultobj;
30765 fail:
30766 return NULL;
30767 }
30768
30769
30770 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30771 PyObject *resultobj = 0;
30772 int result;
30773
30774 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
30775 {
30776 PyThreadState* __tstate = wxPyBeginAllowThreads();
30777 result = (int)wxWindow::NewControlId();
30778 wxPyEndAllowThreads(__tstate);
30779 if (PyErr_Occurred()) SWIG_fail;
30780 }
30781 resultobj = SWIG_From_int(static_cast< int >(result));
30782 return resultobj;
30783 fail:
30784 return NULL;
30785 }
30786
30787
30788 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30789 PyObject *resultobj = 0;
30790 int arg1 ;
30791 int result;
30792 int val1 ;
30793 int ecode1 = 0 ;
30794 PyObject * obj0 = 0 ;
30795 char * kwnames[] = {
30796 (char *) "winid", NULL
30797 };
30798
30799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
30800 ecode1 = SWIG_AsVal_int(obj0, &val1);
30801 if (!SWIG_IsOK(ecode1)) {
30802 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
30803 }
30804 arg1 = static_cast< int >(val1);
30805 {
30806 PyThreadState* __tstate = wxPyBeginAllowThreads();
30807 result = (int)wxWindow::NextControlId(arg1);
30808 wxPyEndAllowThreads(__tstate);
30809 if (PyErr_Occurred()) SWIG_fail;
30810 }
30811 resultobj = SWIG_From_int(static_cast< int >(result));
30812 return resultobj;
30813 fail:
30814 return NULL;
30815 }
30816
30817
30818 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30819 PyObject *resultobj = 0;
30820 int arg1 ;
30821 int result;
30822 int val1 ;
30823 int ecode1 = 0 ;
30824 PyObject * obj0 = 0 ;
30825 char * kwnames[] = {
30826 (char *) "winid", NULL
30827 };
30828
30829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
30830 ecode1 = SWIG_AsVal_int(obj0, &val1);
30831 if (!SWIG_IsOK(ecode1)) {
30832 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
30833 }
30834 arg1 = static_cast< int >(val1);
30835 {
30836 PyThreadState* __tstate = wxPyBeginAllowThreads();
30837 result = (int)wxWindow::PrevControlId(arg1);
30838 wxPyEndAllowThreads(__tstate);
30839 if (PyErr_Occurred()) SWIG_fail;
30840 }
30841 resultobj = SWIG_From_int(static_cast< int >(result));
30842 return resultobj;
30843 fail:
30844 return NULL;
30845 }
30846
30847
30848 SWIGINTERN PyObject *_wrap_Window_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30849 PyObject *resultobj = 0;
30850 wxWindow *arg1 = (wxWindow *) 0 ;
30851 wxLayoutDirection result;
30852 void *argp1 = 0 ;
30853 int res1 = 0 ;
30854 PyObject *swig_obj[1] ;
30855
30856 if (!args) SWIG_fail;
30857 swig_obj[0] = args;
30858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30859 if (!SWIG_IsOK(res1)) {
30860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
30861 }
30862 arg1 = reinterpret_cast< wxWindow * >(argp1);
30863 {
30864 PyThreadState* __tstate = wxPyBeginAllowThreads();
30865 result = (wxLayoutDirection)((wxWindow const *)arg1)->GetLayoutDirection();
30866 wxPyEndAllowThreads(__tstate);
30867 if (PyErr_Occurred()) SWIG_fail;
30868 }
30869 resultobj = SWIG_From_int(static_cast< int >(result));
30870 return resultobj;
30871 fail:
30872 return NULL;
30873 }
30874
30875
30876 SWIGINTERN PyObject *_wrap_Window_SetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30877 PyObject *resultobj = 0;
30878 wxWindow *arg1 = (wxWindow *) 0 ;
30879 wxLayoutDirection arg2 ;
30880 void *argp1 = 0 ;
30881 int res1 = 0 ;
30882 int val2 ;
30883 int ecode2 = 0 ;
30884 PyObject * obj0 = 0 ;
30885 PyObject * obj1 = 0 ;
30886 char * kwnames[] = {
30887 (char *) "self",(char *) "dir", NULL
30888 };
30889
30890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLayoutDirection",kwnames,&obj0,&obj1)) SWIG_fail;
30891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30892 if (!SWIG_IsOK(res1)) {
30893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow *""'");
30894 }
30895 arg1 = reinterpret_cast< wxWindow * >(argp1);
30896 ecode2 = SWIG_AsVal_int(obj1, &val2);
30897 if (!SWIG_IsOK(ecode2)) {
30898 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetLayoutDirection" "', expected argument " "2"" of type '" "wxLayoutDirection""'");
30899 }
30900 arg2 = static_cast< wxLayoutDirection >(val2);
30901 {
30902 PyThreadState* __tstate = wxPyBeginAllowThreads();
30903 (arg1)->SetLayoutDirection(arg2);
30904 wxPyEndAllowThreads(__tstate);
30905 if (PyErr_Occurred()) SWIG_fail;
30906 }
30907 resultobj = SWIG_Py_Void();
30908 return resultobj;
30909 fail:
30910 return NULL;
30911 }
30912
30913
30914 SWIGINTERN PyObject *_wrap_Window_AdjustForLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30915 PyObject *resultobj = 0;
30916 wxWindow *arg1 = (wxWindow *) 0 ;
30917 int arg2 ;
30918 int arg3 ;
30919 int arg4 ;
30920 int result;
30921 void *argp1 = 0 ;
30922 int res1 = 0 ;
30923 int val2 ;
30924 int ecode2 = 0 ;
30925 int val3 ;
30926 int ecode3 = 0 ;
30927 int val4 ;
30928 int ecode4 = 0 ;
30929 PyObject * obj0 = 0 ;
30930 PyObject * obj1 = 0 ;
30931 PyObject * obj2 = 0 ;
30932 PyObject * obj3 = 0 ;
30933 char * kwnames[] = {
30934 (char *) "self",(char *) "x",(char *) "width",(char *) "widthTotal", NULL
30935 };
30936
30937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_AdjustForLayoutDirection",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30939 if (!SWIG_IsOK(res1)) {
30940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
30941 }
30942 arg1 = reinterpret_cast< wxWindow * >(argp1);
30943 ecode2 = SWIG_AsVal_int(obj1, &val2);
30944 if (!SWIG_IsOK(ecode2)) {
30945 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "2"" of type '" "int""'");
30946 }
30947 arg2 = static_cast< int >(val2);
30948 ecode3 = SWIG_AsVal_int(obj2, &val3);
30949 if (!SWIG_IsOK(ecode3)) {
30950 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "3"" of type '" "int""'");
30951 }
30952 arg3 = static_cast< int >(val3);
30953 ecode4 = SWIG_AsVal_int(obj3, &val4);
30954 if (!SWIG_IsOK(ecode4)) {
30955 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "4"" of type '" "int""'");
30956 }
30957 arg4 = static_cast< int >(val4);
30958 {
30959 PyThreadState* __tstate = wxPyBeginAllowThreads();
30960 result = (int)((wxWindow const *)arg1)->AdjustForLayoutDirection(arg2,arg3,arg4);
30961 wxPyEndAllowThreads(__tstate);
30962 if (PyErr_Occurred()) SWIG_fail;
30963 }
30964 resultobj = SWIG_From_int(static_cast< int >(result));
30965 return resultobj;
30966 fail:
30967 return NULL;
30968 }
30969
30970
30971 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30972 PyObject *resultobj = 0;
30973 wxWindow *arg1 = (wxWindow *) 0 ;
30974 wxSize *arg2 = 0 ;
30975 void *argp1 = 0 ;
30976 int res1 = 0 ;
30977 wxSize temp2 ;
30978 PyObject * obj0 = 0 ;
30979 PyObject * obj1 = 0 ;
30980 char * kwnames[] = {
30981 (char *) "self",(char *) "size", NULL
30982 };
30983
30984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
30985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30986 if (!SWIG_IsOK(res1)) {
30987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30988 }
30989 arg1 = reinterpret_cast< wxWindow * >(argp1);
30990 {
30991 arg2 = &temp2;
30992 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30993 }
30994 {
30995 PyThreadState* __tstate = wxPyBeginAllowThreads();
30996 (arg1)->SetSize((wxSize const &)*arg2);
30997 wxPyEndAllowThreads(__tstate);
30998 if (PyErr_Occurred()) SWIG_fail;
30999 }
31000 resultobj = SWIG_Py_Void();
31001 return resultobj;
31002 fail:
31003 return NULL;
31004 }
31005
31006
31007 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31008 PyObject *resultobj = 0;
31009 wxWindow *arg1 = (wxWindow *) 0 ;
31010 int arg2 ;
31011 int arg3 ;
31012 int arg4 ;
31013 int arg5 ;
31014 int arg6 = (int) wxSIZE_AUTO ;
31015 void *argp1 = 0 ;
31016 int res1 = 0 ;
31017 int val2 ;
31018 int ecode2 = 0 ;
31019 int val3 ;
31020 int ecode3 = 0 ;
31021 int val4 ;
31022 int ecode4 = 0 ;
31023 int val5 ;
31024 int ecode5 = 0 ;
31025 int val6 ;
31026 int ecode6 = 0 ;
31027 PyObject * obj0 = 0 ;
31028 PyObject * obj1 = 0 ;
31029 PyObject * obj2 = 0 ;
31030 PyObject * obj3 = 0 ;
31031 PyObject * obj4 = 0 ;
31032 PyObject * obj5 = 0 ;
31033 char * kwnames[] = {
31034 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
31035 };
31036
31037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
31038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31039 if (!SWIG_IsOK(res1)) {
31040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
31041 }
31042 arg1 = reinterpret_cast< wxWindow * >(argp1);
31043 ecode2 = SWIG_AsVal_int(obj1, &val2);
31044 if (!SWIG_IsOK(ecode2)) {
31045 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
31046 }
31047 arg2 = static_cast< int >(val2);
31048 ecode3 = SWIG_AsVal_int(obj2, &val3);
31049 if (!SWIG_IsOK(ecode3)) {
31050 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
31051 }
31052 arg3 = static_cast< int >(val3);
31053 ecode4 = SWIG_AsVal_int(obj3, &val4);
31054 if (!SWIG_IsOK(ecode4)) {
31055 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
31056 }
31057 arg4 = static_cast< int >(val4);
31058 ecode5 = SWIG_AsVal_int(obj4, &val5);
31059 if (!SWIG_IsOK(ecode5)) {
31060 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
31061 }
31062 arg5 = static_cast< int >(val5);
31063 if (obj5) {
31064 ecode6 = SWIG_AsVal_int(obj5, &val6);
31065 if (!SWIG_IsOK(ecode6)) {
31066 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
31067 }
31068 arg6 = static_cast< int >(val6);
31069 }
31070 {
31071 PyThreadState* __tstate = wxPyBeginAllowThreads();
31072 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
31073 wxPyEndAllowThreads(__tstate);
31074 if (PyErr_Occurred()) SWIG_fail;
31075 }
31076 resultobj = SWIG_Py_Void();
31077 return resultobj;
31078 fail:
31079 return NULL;
31080 }
31081
31082
31083 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31084 PyObject *resultobj = 0;
31085 wxWindow *arg1 = (wxWindow *) 0 ;
31086 wxRect *arg2 = 0 ;
31087 int arg3 = (int) wxSIZE_AUTO ;
31088 void *argp1 = 0 ;
31089 int res1 = 0 ;
31090 wxRect temp2 ;
31091 int val3 ;
31092 int ecode3 = 0 ;
31093 PyObject * obj0 = 0 ;
31094 PyObject * obj1 = 0 ;
31095 PyObject * obj2 = 0 ;
31096 char * kwnames[] = {
31097 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
31098 };
31099
31100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31102 if (!SWIG_IsOK(res1)) {
31103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
31104 }
31105 arg1 = reinterpret_cast< wxWindow * >(argp1);
31106 {
31107 arg2 = &temp2;
31108 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
31109 }
31110 if (obj2) {
31111 ecode3 = SWIG_AsVal_int(obj2, &val3);
31112 if (!SWIG_IsOK(ecode3)) {
31113 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
31114 }
31115 arg3 = static_cast< int >(val3);
31116 }
31117 {
31118 PyThreadState* __tstate = wxPyBeginAllowThreads();
31119 (arg1)->SetSize((wxRect const &)*arg2,arg3);
31120 wxPyEndAllowThreads(__tstate);
31121 if (PyErr_Occurred()) SWIG_fail;
31122 }
31123 resultobj = SWIG_Py_Void();
31124 return resultobj;
31125 fail:
31126 return NULL;
31127 }
31128
31129
31130 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31131 PyObject *resultobj = 0;
31132 wxWindow *arg1 = (wxWindow *) 0 ;
31133 int arg2 ;
31134 int arg3 ;
31135 void *argp1 = 0 ;
31136 int res1 = 0 ;
31137 int val2 ;
31138 int ecode2 = 0 ;
31139 int val3 ;
31140 int ecode3 = 0 ;
31141 PyObject * obj0 = 0 ;
31142 PyObject * obj1 = 0 ;
31143 PyObject * obj2 = 0 ;
31144 char * kwnames[] = {
31145 (char *) "self",(char *) "width",(char *) "height", NULL
31146 };
31147
31148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31150 if (!SWIG_IsOK(res1)) {
31151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31152 }
31153 arg1 = reinterpret_cast< wxWindow * >(argp1);
31154 ecode2 = SWIG_AsVal_int(obj1, &val2);
31155 if (!SWIG_IsOK(ecode2)) {
31156 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
31157 }
31158 arg2 = static_cast< int >(val2);
31159 ecode3 = SWIG_AsVal_int(obj2, &val3);
31160 if (!SWIG_IsOK(ecode3)) {
31161 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
31162 }
31163 arg3 = static_cast< int >(val3);
31164 {
31165 PyThreadState* __tstate = wxPyBeginAllowThreads();
31166 (arg1)->SetSize(arg2,arg3);
31167 wxPyEndAllowThreads(__tstate);
31168 if (PyErr_Occurred()) SWIG_fail;
31169 }
31170 resultobj = SWIG_Py_Void();
31171 return resultobj;
31172 fail:
31173 return NULL;
31174 }
31175
31176
31177 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31178 PyObject *resultobj = 0;
31179 wxWindow *arg1 = (wxWindow *) 0 ;
31180 wxPoint *arg2 = 0 ;
31181 int arg3 = (int) wxSIZE_USE_EXISTING ;
31182 void *argp1 = 0 ;
31183 int res1 = 0 ;
31184 wxPoint temp2 ;
31185 int val3 ;
31186 int ecode3 = 0 ;
31187 PyObject * obj0 = 0 ;
31188 PyObject * obj1 = 0 ;
31189 PyObject * obj2 = 0 ;
31190 char * kwnames[] = {
31191 (char *) "self",(char *) "pt",(char *) "flags", NULL
31192 };
31193
31194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31196 if (!SWIG_IsOK(res1)) {
31197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
31198 }
31199 arg1 = reinterpret_cast< wxWindow * >(argp1);
31200 {
31201 arg2 = &temp2;
31202 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31203 }
31204 if (obj2) {
31205 ecode3 = SWIG_AsVal_int(obj2, &val3);
31206 if (!SWIG_IsOK(ecode3)) {
31207 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
31208 }
31209 arg3 = static_cast< int >(val3);
31210 }
31211 {
31212 PyThreadState* __tstate = wxPyBeginAllowThreads();
31213 (arg1)->Move((wxPoint const &)*arg2,arg3);
31214 wxPyEndAllowThreads(__tstate);
31215 if (PyErr_Occurred()) SWIG_fail;
31216 }
31217 resultobj = SWIG_Py_Void();
31218 return resultobj;
31219 fail:
31220 return NULL;
31221 }
31222
31223
31224 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31225 PyObject *resultobj = 0;
31226 wxWindow *arg1 = (wxWindow *) 0 ;
31227 int arg2 ;
31228 int arg3 ;
31229 int arg4 = (int) wxSIZE_USE_EXISTING ;
31230 void *argp1 = 0 ;
31231 int res1 = 0 ;
31232 int val2 ;
31233 int ecode2 = 0 ;
31234 int val3 ;
31235 int ecode3 = 0 ;
31236 int val4 ;
31237 int ecode4 = 0 ;
31238 PyObject * obj0 = 0 ;
31239 PyObject * obj1 = 0 ;
31240 PyObject * obj2 = 0 ;
31241 PyObject * obj3 = 0 ;
31242 char * kwnames[] = {
31243 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
31244 };
31245
31246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31248 if (!SWIG_IsOK(res1)) {
31249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
31250 }
31251 arg1 = reinterpret_cast< wxWindow * >(argp1);
31252 ecode2 = SWIG_AsVal_int(obj1, &val2);
31253 if (!SWIG_IsOK(ecode2)) {
31254 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
31255 }
31256 arg2 = static_cast< int >(val2);
31257 ecode3 = SWIG_AsVal_int(obj2, &val3);
31258 if (!SWIG_IsOK(ecode3)) {
31259 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
31260 }
31261 arg3 = static_cast< int >(val3);
31262 if (obj3) {
31263 ecode4 = SWIG_AsVal_int(obj3, &val4);
31264 if (!SWIG_IsOK(ecode4)) {
31265 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
31266 }
31267 arg4 = static_cast< int >(val4);
31268 }
31269 {
31270 PyThreadState* __tstate = wxPyBeginAllowThreads();
31271 (arg1)->Move(arg2,arg3,arg4);
31272 wxPyEndAllowThreads(__tstate);
31273 if (PyErr_Occurred()) SWIG_fail;
31274 }
31275 resultobj = SWIG_Py_Void();
31276 return resultobj;
31277 fail:
31278 return NULL;
31279 }
31280
31281
31282 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31283 PyObject *resultobj = 0;
31284 wxWindow *arg1 = (wxWindow *) 0 ;
31285 wxSize const &arg2_defvalue = wxDefaultSize ;
31286 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
31287 void *argp1 = 0 ;
31288 int res1 = 0 ;
31289 wxSize temp2 ;
31290 PyObject * obj0 = 0 ;
31291 PyObject * obj1 = 0 ;
31292 char * kwnames[] = {
31293 (char *) "self",(char *) "size", NULL
31294 };
31295
31296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
31297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31298 if (!SWIG_IsOK(res1)) {
31299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31300 }
31301 arg1 = reinterpret_cast< wxWindow * >(argp1);
31302 if (obj1) {
31303 {
31304 arg2 = &temp2;
31305 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31306 }
31307 }
31308 {
31309 PyThreadState* __tstate = wxPyBeginAllowThreads();
31310 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
31311 wxPyEndAllowThreads(__tstate);
31312 if (PyErr_Occurred()) SWIG_fail;
31313 }
31314 resultobj = SWIG_Py_Void();
31315 return resultobj;
31316 fail:
31317 return NULL;
31318 }
31319
31320
31321 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31322 PyObject *resultobj = 0;
31323 wxWindow *arg1 = (wxWindow *) 0 ;
31324 void *argp1 = 0 ;
31325 int res1 = 0 ;
31326 PyObject *swig_obj[1] ;
31327
31328 if (!args) SWIG_fail;
31329 swig_obj[0] = args;
31330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31331 if (!SWIG_IsOK(res1)) {
31332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
31333 }
31334 arg1 = reinterpret_cast< wxWindow * >(argp1);
31335 {
31336 PyThreadState* __tstate = wxPyBeginAllowThreads();
31337 (arg1)->Raise();
31338 wxPyEndAllowThreads(__tstate);
31339 if (PyErr_Occurred()) SWIG_fail;
31340 }
31341 resultobj = SWIG_Py_Void();
31342 return resultobj;
31343 fail:
31344 return NULL;
31345 }
31346
31347
31348 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31349 PyObject *resultobj = 0;
31350 wxWindow *arg1 = (wxWindow *) 0 ;
31351 void *argp1 = 0 ;
31352 int res1 = 0 ;
31353 PyObject *swig_obj[1] ;
31354
31355 if (!args) SWIG_fail;
31356 swig_obj[0] = args;
31357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31358 if (!SWIG_IsOK(res1)) {
31359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
31360 }
31361 arg1 = reinterpret_cast< wxWindow * >(argp1);
31362 {
31363 PyThreadState* __tstate = wxPyBeginAllowThreads();
31364 (arg1)->Lower();
31365 wxPyEndAllowThreads(__tstate);
31366 if (PyErr_Occurred()) SWIG_fail;
31367 }
31368 resultobj = SWIG_Py_Void();
31369 return resultobj;
31370 fail:
31371 return NULL;
31372 }
31373
31374
31375 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31376 PyObject *resultobj = 0;
31377 wxWindow *arg1 = (wxWindow *) 0 ;
31378 wxSize *arg2 = 0 ;
31379 void *argp1 = 0 ;
31380 int res1 = 0 ;
31381 wxSize temp2 ;
31382 PyObject * obj0 = 0 ;
31383 PyObject * obj1 = 0 ;
31384 char * kwnames[] = {
31385 (char *) "self",(char *) "size", NULL
31386 };
31387
31388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
31389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31390 if (!SWIG_IsOK(res1)) {
31391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31392 }
31393 arg1 = reinterpret_cast< wxWindow * >(argp1);
31394 {
31395 arg2 = &temp2;
31396 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31397 }
31398 {
31399 PyThreadState* __tstate = wxPyBeginAllowThreads();
31400 (arg1)->SetClientSize((wxSize const &)*arg2);
31401 wxPyEndAllowThreads(__tstate);
31402 if (PyErr_Occurred()) SWIG_fail;
31403 }
31404 resultobj = SWIG_Py_Void();
31405 return resultobj;
31406 fail:
31407 return NULL;
31408 }
31409
31410
31411 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31412 PyObject *resultobj = 0;
31413 wxWindow *arg1 = (wxWindow *) 0 ;
31414 int arg2 ;
31415 int arg3 ;
31416 void *argp1 = 0 ;
31417 int res1 = 0 ;
31418 int val2 ;
31419 int ecode2 = 0 ;
31420 int val3 ;
31421 int ecode3 = 0 ;
31422 PyObject * obj0 = 0 ;
31423 PyObject * obj1 = 0 ;
31424 PyObject * obj2 = 0 ;
31425 char * kwnames[] = {
31426 (char *) "self",(char *) "width",(char *) "height", NULL
31427 };
31428
31429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31431 if (!SWIG_IsOK(res1)) {
31432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31433 }
31434 arg1 = reinterpret_cast< wxWindow * >(argp1);
31435 ecode2 = SWIG_AsVal_int(obj1, &val2);
31436 if (!SWIG_IsOK(ecode2)) {
31437 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
31438 }
31439 arg2 = static_cast< int >(val2);
31440 ecode3 = SWIG_AsVal_int(obj2, &val3);
31441 if (!SWIG_IsOK(ecode3)) {
31442 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
31443 }
31444 arg3 = static_cast< int >(val3);
31445 {
31446 PyThreadState* __tstate = wxPyBeginAllowThreads();
31447 (arg1)->SetClientSize(arg2,arg3);
31448 wxPyEndAllowThreads(__tstate);
31449 if (PyErr_Occurred()) SWIG_fail;
31450 }
31451 resultobj = SWIG_Py_Void();
31452 return resultobj;
31453 fail:
31454 return NULL;
31455 }
31456
31457
31458 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31459 PyObject *resultobj = 0;
31460 wxWindow *arg1 = (wxWindow *) 0 ;
31461 wxRect *arg2 = 0 ;
31462 void *argp1 = 0 ;
31463 int res1 = 0 ;
31464 wxRect temp2 ;
31465 PyObject * obj0 = 0 ;
31466 PyObject * obj1 = 0 ;
31467 char * kwnames[] = {
31468 (char *) "self",(char *) "rect", NULL
31469 };
31470
31471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
31472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31473 if (!SWIG_IsOK(res1)) {
31474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
31475 }
31476 arg1 = reinterpret_cast< wxWindow * >(argp1);
31477 {
31478 arg2 = &temp2;
31479 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
31480 }
31481 {
31482 PyThreadState* __tstate = wxPyBeginAllowThreads();
31483 (arg1)->SetClientSize((wxRect const &)*arg2);
31484 wxPyEndAllowThreads(__tstate);
31485 if (PyErr_Occurred()) SWIG_fail;
31486 }
31487 resultobj = SWIG_Py_Void();
31488 return resultobj;
31489 fail:
31490 return NULL;
31491 }
31492
31493
31494 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31495 PyObject *resultobj = 0;
31496 wxWindow *arg1 = (wxWindow *) 0 ;
31497 wxPoint result;
31498 void *argp1 = 0 ;
31499 int res1 = 0 ;
31500 PyObject *swig_obj[1] ;
31501
31502 if (!args) SWIG_fail;
31503 swig_obj[0] = args;
31504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31505 if (!SWIG_IsOK(res1)) {
31506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
31507 }
31508 arg1 = reinterpret_cast< wxWindow * >(argp1);
31509 {
31510 PyThreadState* __tstate = wxPyBeginAllowThreads();
31511 result = ((wxWindow const *)arg1)->GetPosition();
31512 wxPyEndAllowThreads(__tstate);
31513 if (PyErr_Occurred()) SWIG_fail;
31514 }
31515 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31516 return resultobj;
31517 fail:
31518 return NULL;
31519 }
31520
31521
31522 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31523 PyObject *resultobj = 0;
31524 wxWindow *arg1 = (wxWindow *) 0 ;
31525 int *arg2 = (int *) 0 ;
31526 int *arg3 = (int *) 0 ;
31527 void *argp1 = 0 ;
31528 int res1 = 0 ;
31529 int temp2 ;
31530 int res2 = SWIG_TMPOBJ ;
31531 int temp3 ;
31532 int res3 = SWIG_TMPOBJ ;
31533 PyObject *swig_obj[1] ;
31534
31535 arg2 = &temp2;
31536 arg3 = &temp3;
31537 if (!args) SWIG_fail;
31538 swig_obj[0] = args;
31539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31540 if (!SWIG_IsOK(res1)) {
31541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31542 }
31543 arg1 = reinterpret_cast< wxWindow * >(argp1);
31544 {
31545 PyThreadState* __tstate = wxPyBeginAllowThreads();
31546 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
31547 wxPyEndAllowThreads(__tstate);
31548 if (PyErr_Occurred()) SWIG_fail;
31549 }
31550 resultobj = SWIG_Py_Void();
31551 if (SWIG_IsTmpObj(res2)) {
31552 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31553 } else {
31554 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31555 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31556 }
31557 if (SWIG_IsTmpObj(res3)) {
31558 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31559 } else {
31560 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31561 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31562 }
31563 return resultobj;
31564 fail:
31565 return NULL;
31566 }
31567
31568
31569 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31570 PyObject *resultobj = 0;
31571 wxWindow *arg1 = (wxWindow *) 0 ;
31572 wxPoint result;
31573 void *argp1 = 0 ;
31574 int res1 = 0 ;
31575 PyObject *swig_obj[1] ;
31576
31577 if (!args) SWIG_fail;
31578 swig_obj[0] = args;
31579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31580 if (!SWIG_IsOK(res1)) {
31581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
31582 }
31583 arg1 = reinterpret_cast< wxWindow * >(argp1);
31584 {
31585 PyThreadState* __tstate = wxPyBeginAllowThreads();
31586 result = ((wxWindow const *)arg1)->GetScreenPosition();
31587 wxPyEndAllowThreads(__tstate);
31588 if (PyErr_Occurred()) SWIG_fail;
31589 }
31590 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31591 return resultobj;
31592 fail:
31593 return NULL;
31594 }
31595
31596
31597 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31598 PyObject *resultobj = 0;
31599 wxWindow *arg1 = (wxWindow *) 0 ;
31600 int *arg2 = (int *) 0 ;
31601 int *arg3 = (int *) 0 ;
31602 void *argp1 = 0 ;
31603 int res1 = 0 ;
31604 int temp2 ;
31605 int res2 = SWIG_TMPOBJ ;
31606 int temp3 ;
31607 int res3 = SWIG_TMPOBJ ;
31608 PyObject *swig_obj[1] ;
31609
31610 arg2 = &temp2;
31611 arg3 = &temp3;
31612 if (!args) SWIG_fail;
31613 swig_obj[0] = args;
31614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31615 if (!SWIG_IsOK(res1)) {
31616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31617 }
31618 arg1 = reinterpret_cast< wxWindow * >(argp1);
31619 {
31620 PyThreadState* __tstate = wxPyBeginAllowThreads();
31621 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
31622 wxPyEndAllowThreads(__tstate);
31623 if (PyErr_Occurred()) SWIG_fail;
31624 }
31625 resultobj = SWIG_Py_Void();
31626 if (SWIG_IsTmpObj(res2)) {
31627 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31628 } else {
31629 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31630 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31631 }
31632 if (SWIG_IsTmpObj(res3)) {
31633 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31634 } else {
31635 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31636 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31637 }
31638 return resultobj;
31639 fail:
31640 return NULL;
31641 }
31642
31643
31644 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31645 PyObject *resultobj = 0;
31646 wxWindow *arg1 = (wxWindow *) 0 ;
31647 wxRect result;
31648 void *argp1 = 0 ;
31649 int res1 = 0 ;
31650 PyObject *swig_obj[1] ;
31651
31652 if (!args) SWIG_fail;
31653 swig_obj[0] = args;
31654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31655 if (!SWIG_IsOK(res1)) {
31656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31657 }
31658 arg1 = reinterpret_cast< wxWindow * >(argp1);
31659 {
31660 PyThreadState* __tstate = wxPyBeginAllowThreads();
31661 result = ((wxWindow const *)arg1)->GetScreenRect();
31662 wxPyEndAllowThreads(__tstate);
31663 if (PyErr_Occurred()) SWIG_fail;
31664 }
31665 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31666 return resultobj;
31667 fail:
31668 return NULL;
31669 }
31670
31671
31672 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31673 PyObject *resultobj = 0;
31674 wxWindow *arg1 = (wxWindow *) 0 ;
31675 wxSize result;
31676 void *argp1 = 0 ;
31677 int res1 = 0 ;
31678 PyObject *swig_obj[1] ;
31679
31680 if (!args) SWIG_fail;
31681 swig_obj[0] = args;
31682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31683 if (!SWIG_IsOK(res1)) {
31684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31685 }
31686 arg1 = reinterpret_cast< wxWindow * >(argp1);
31687 {
31688 PyThreadState* __tstate = wxPyBeginAllowThreads();
31689 result = ((wxWindow const *)arg1)->GetSize();
31690 wxPyEndAllowThreads(__tstate);
31691 if (PyErr_Occurred()) SWIG_fail;
31692 }
31693 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31694 return resultobj;
31695 fail:
31696 return NULL;
31697 }
31698
31699
31700 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31701 PyObject *resultobj = 0;
31702 wxWindow *arg1 = (wxWindow *) 0 ;
31703 int *arg2 = (int *) 0 ;
31704 int *arg3 = (int *) 0 ;
31705 void *argp1 = 0 ;
31706 int res1 = 0 ;
31707 int temp2 ;
31708 int res2 = SWIG_TMPOBJ ;
31709 int temp3 ;
31710 int res3 = SWIG_TMPOBJ ;
31711 PyObject *swig_obj[1] ;
31712
31713 arg2 = &temp2;
31714 arg3 = &temp3;
31715 if (!args) SWIG_fail;
31716 swig_obj[0] = args;
31717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31718 if (!SWIG_IsOK(res1)) {
31719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31720 }
31721 arg1 = reinterpret_cast< wxWindow * >(argp1);
31722 {
31723 PyThreadState* __tstate = wxPyBeginAllowThreads();
31724 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
31725 wxPyEndAllowThreads(__tstate);
31726 if (PyErr_Occurred()) SWIG_fail;
31727 }
31728 resultobj = SWIG_Py_Void();
31729 if (SWIG_IsTmpObj(res2)) {
31730 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31731 } else {
31732 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31733 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31734 }
31735 if (SWIG_IsTmpObj(res3)) {
31736 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31737 } else {
31738 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31739 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31740 }
31741 return resultobj;
31742 fail:
31743 return NULL;
31744 }
31745
31746
31747 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31748 PyObject *resultobj = 0;
31749 wxWindow *arg1 = (wxWindow *) 0 ;
31750 wxRect result;
31751 void *argp1 = 0 ;
31752 int res1 = 0 ;
31753 PyObject *swig_obj[1] ;
31754
31755 if (!args) SWIG_fail;
31756 swig_obj[0] = args;
31757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31758 if (!SWIG_IsOK(res1)) {
31759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31760 }
31761 arg1 = reinterpret_cast< wxWindow * >(argp1);
31762 {
31763 PyThreadState* __tstate = wxPyBeginAllowThreads();
31764 result = ((wxWindow const *)arg1)->GetRect();
31765 wxPyEndAllowThreads(__tstate);
31766 if (PyErr_Occurred()) SWIG_fail;
31767 }
31768 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31769 return resultobj;
31770 fail:
31771 return NULL;
31772 }
31773
31774
31775 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31776 PyObject *resultobj = 0;
31777 wxWindow *arg1 = (wxWindow *) 0 ;
31778 wxSize result;
31779 void *argp1 = 0 ;
31780 int res1 = 0 ;
31781 PyObject *swig_obj[1] ;
31782
31783 if (!args) SWIG_fail;
31784 swig_obj[0] = args;
31785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31786 if (!SWIG_IsOK(res1)) {
31787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31788 }
31789 arg1 = reinterpret_cast< wxWindow * >(argp1);
31790 {
31791 PyThreadState* __tstate = wxPyBeginAllowThreads();
31792 result = ((wxWindow const *)arg1)->GetClientSize();
31793 wxPyEndAllowThreads(__tstate);
31794 if (PyErr_Occurred()) SWIG_fail;
31795 }
31796 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31797 return resultobj;
31798 fail:
31799 return NULL;
31800 }
31801
31802
31803 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31804 PyObject *resultobj = 0;
31805 wxWindow *arg1 = (wxWindow *) 0 ;
31806 int *arg2 = (int *) 0 ;
31807 int *arg3 = (int *) 0 ;
31808 void *argp1 = 0 ;
31809 int res1 = 0 ;
31810 int temp2 ;
31811 int res2 = SWIG_TMPOBJ ;
31812 int temp3 ;
31813 int res3 = SWIG_TMPOBJ ;
31814 PyObject *swig_obj[1] ;
31815
31816 arg2 = &temp2;
31817 arg3 = &temp3;
31818 if (!args) SWIG_fail;
31819 swig_obj[0] = args;
31820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31821 if (!SWIG_IsOK(res1)) {
31822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31823 }
31824 arg1 = reinterpret_cast< wxWindow * >(argp1);
31825 {
31826 PyThreadState* __tstate = wxPyBeginAllowThreads();
31827 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
31828 wxPyEndAllowThreads(__tstate);
31829 if (PyErr_Occurred()) SWIG_fail;
31830 }
31831 resultobj = SWIG_Py_Void();
31832 if (SWIG_IsTmpObj(res2)) {
31833 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31834 } else {
31835 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31836 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31837 }
31838 if (SWIG_IsTmpObj(res3)) {
31839 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31840 } else {
31841 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31842 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31843 }
31844 return resultobj;
31845 fail:
31846 return NULL;
31847 }
31848
31849
31850 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31851 PyObject *resultobj = 0;
31852 wxWindow *arg1 = (wxWindow *) 0 ;
31853 wxPoint 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_wxWindow, 0 | 0 );
31861 if (!SWIG_IsOK(res1)) {
31862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
31863 }
31864 arg1 = reinterpret_cast< wxWindow * >(argp1);
31865 {
31866 PyThreadState* __tstate = wxPyBeginAllowThreads();
31867 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
31868 wxPyEndAllowThreads(__tstate);
31869 if (PyErr_Occurred()) SWIG_fail;
31870 }
31871 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31872 return resultobj;
31873 fail:
31874 return NULL;
31875 }
31876
31877
31878 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31879 PyObject *resultobj = 0;
31880 wxWindow *arg1 = (wxWindow *) 0 ;
31881 wxRect result;
31882 void *argp1 = 0 ;
31883 int res1 = 0 ;
31884 PyObject *swig_obj[1] ;
31885
31886 if (!args) SWIG_fail;
31887 swig_obj[0] = args;
31888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31889 if (!SWIG_IsOK(res1)) {
31890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31891 }
31892 arg1 = reinterpret_cast< wxWindow * >(argp1);
31893 {
31894 PyThreadState* __tstate = wxPyBeginAllowThreads();
31895 result = ((wxWindow const *)arg1)->GetClientRect();
31896 wxPyEndAllowThreads(__tstate);
31897 if (PyErr_Occurred()) SWIG_fail;
31898 }
31899 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31900 return resultobj;
31901 fail:
31902 return NULL;
31903 }
31904
31905
31906 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31907 PyObject *resultobj = 0;
31908 wxWindow *arg1 = (wxWindow *) 0 ;
31909 wxSize result;
31910 void *argp1 = 0 ;
31911 int res1 = 0 ;
31912 PyObject *swig_obj[1] ;
31913
31914 if (!args) SWIG_fail;
31915 swig_obj[0] = args;
31916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31917 if (!SWIG_IsOK(res1)) {
31918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31919 }
31920 arg1 = reinterpret_cast< wxWindow * >(argp1);
31921 {
31922 PyThreadState* __tstate = wxPyBeginAllowThreads();
31923 result = ((wxWindow const *)arg1)->GetBestSize();
31924 wxPyEndAllowThreads(__tstate);
31925 if (PyErr_Occurred()) SWIG_fail;
31926 }
31927 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31928 return resultobj;
31929 fail:
31930 return NULL;
31931 }
31932
31933
31934 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31935 PyObject *resultobj = 0;
31936 wxWindow *arg1 = (wxWindow *) 0 ;
31937 int *arg2 = (int *) 0 ;
31938 int *arg3 = (int *) 0 ;
31939 void *argp1 = 0 ;
31940 int res1 = 0 ;
31941 int temp2 ;
31942 int res2 = SWIG_TMPOBJ ;
31943 int temp3 ;
31944 int res3 = SWIG_TMPOBJ ;
31945 PyObject *swig_obj[1] ;
31946
31947 arg2 = &temp2;
31948 arg3 = &temp3;
31949 if (!args) SWIG_fail;
31950 swig_obj[0] = args;
31951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31952 if (!SWIG_IsOK(res1)) {
31953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31954 }
31955 arg1 = reinterpret_cast< wxWindow * >(argp1);
31956 {
31957 PyThreadState* __tstate = wxPyBeginAllowThreads();
31958 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
31959 wxPyEndAllowThreads(__tstate);
31960 if (PyErr_Occurred()) SWIG_fail;
31961 }
31962 resultobj = SWIG_Py_Void();
31963 if (SWIG_IsTmpObj(res2)) {
31964 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31965 } else {
31966 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31967 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31968 }
31969 if (SWIG_IsTmpObj(res3)) {
31970 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31971 } else {
31972 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31973 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31974 }
31975 return resultobj;
31976 fail:
31977 return NULL;
31978 }
31979
31980
31981 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31982 PyObject *resultobj = 0;
31983 wxWindow *arg1 = (wxWindow *) 0 ;
31984 void *argp1 = 0 ;
31985 int res1 = 0 ;
31986 PyObject *swig_obj[1] ;
31987
31988 if (!args) SWIG_fail;
31989 swig_obj[0] = args;
31990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31991 if (!SWIG_IsOK(res1)) {
31992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31993 }
31994 arg1 = reinterpret_cast< wxWindow * >(argp1);
31995 {
31996 PyThreadState* __tstate = wxPyBeginAllowThreads();
31997 (arg1)->InvalidateBestSize();
31998 wxPyEndAllowThreads(__tstate);
31999 if (PyErr_Occurred()) SWIG_fail;
32000 }
32001 resultobj = SWIG_Py_Void();
32002 return resultobj;
32003 fail:
32004 return NULL;
32005 }
32006
32007
32008 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32009 PyObject *resultobj = 0;
32010 wxWindow *arg1 = (wxWindow *) 0 ;
32011 wxSize *arg2 = 0 ;
32012 void *argp1 = 0 ;
32013 int res1 = 0 ;
32014 wxSize temp2 ;
32015 PyObject * obj0 = 0 ;
32016 PyObject * obj1 = 0 ;
32017 char * kwnames[] = {
32018 (char *) "self",(char *) "size", NULL
32019 };
32020
32021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
32022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32023 if (!SWIG_IsOK(res1)) {
32024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32025 }
32026 arg1 = reinterpret_cast< wxWindow * >(argp1);
32027 {
32028 arg2 = &temp2;
32029 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32030 }
32031 {
32032 PyThreadState* __tstate = wxPyBeginAllowThreads();
32033 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
32034 wxPyEndAllowThreads(__tstate);
32035 if (PyErr_Occurred()) SWIG_fail;
32036 }
32037 resultobj = SWIG_Py_Void();
32038 return resultobj;
32039 fail:
32040 return NULL;
32041 }
32042
32043
32044 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32045 PyObject *resultobj = 0;
32046 wxWindow *arg1 = (wxWindow *) 0 ;
32047 wxSize result;
32048 void *argp1 = 0 ;
32049 int res1 = 0 ;
32050 PyObject *swig_obj[1] ;
32051
32052 if (!args) SWIG_fail;
32053 swig_obj[0] = args;
32054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32055 if (!SWIG_IsOK(res1)) {
32056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32057 }
32058 arg1 = reinterpret_cast< wxWindow * >(argp1);
32059 {
32060 PyThreadState* __tstate = wxPyBeginAllowThreads();
32061 result = ((wxWindow const *)arg1)->GetBestFittingSize();
32062 wxPyEndAllowThreads(__tstate);
32063 if (PyErr_Occurred()) SWIG_fail;
32064 }
32065 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32066 return resultobj;
32067 fail:
32068 return NULL;
32069 }
32070
32071
32072 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32073 PyObject *resultobj = 0;
32074 wxWindow *arg1 = (wxWindow *) 0 ;
32075 wxSize result;
32076 void *argp1 = 0 ;
32077 int res1 = 0 ;
32078 PyObject *swig_obj[1] ;
32079
32080 if (!args) SWIG_fail;
32081 swig_obj[0] = args;
32082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32083 if (!SWIG_IsOK(res1)) {
32084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32085 }
32086 arg1 = reinterpret_cast< wxWindow * >(argp1);
32087 {
32088 PyThreadState* __tstate = wxPyBeginAllowThreads();
32089 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
32090 wxPyEndAllowThreads(__tstate);
32091 if (PyErr_Occurred()) SWIG_fail;
32092 }
32093 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32094 return resultobj;
32095 fail:
32096 return NULL;
32097 }
32098
32099
32100 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32101 PyObject *resultobj = 0;
32102 wxWindow *arg1 = (wxWindow *) 0 ;
32103 int arg2 = (int) wxBOTH ;
32104 void *argp1 = 0 ;
32105 int res1 = 0 ;
32106 int val2 ;
32107 int ecode2 = 0 ;
32108 PyObject * obj0 = 0 ;
32109 PyObject * obj1 = 0 ;
32110 char * kwnames[] = {
32111 (char *) "self",(char *) "direction", NULL
32112 };
32113
32114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
32115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32116 if (!SWIG_IsOK(res1)) {
32117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
32118 }
32119 arg1 = reinterpret_cast< wxWindow * >(argp1);
32120 if (obj1) {
32121 ecode2 = SWIG_AsVal_int(obj1, &val2);
32122 if (!SWIG_IsOK(ecode2)) {
32123 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
32124 }
32125 arg2 = static_cast< int >(val2);
32126 }
32127 {
32128 PyThreadState* __tstate = wxPyBeginAllowThreads();
32129 (arg1)->Center(arg2);
32130 wxPyEndAllowThreads(__tstate);
32131 if (PyErr_Occurred()) SWIG_fail;
32132 }
32133 resultobj = SWIG_Py_Void();
32134 return resultobj;
32135 fail:
32136 return NULL;
32137 }
32138
32139
32140 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32141 PyObject *resultobj = 0;
32142 wxWindow *arg1 = (wxWindow *) 0 ;
32143 int arg2 = (int) wxBOTH ;
32144 void *argp1 = 0 ;
32145 int res1 = 0 ;
32146 int val2 ;
32147 int ecode2 = 0 ;
32148 PyObject * obj0 = 0 ;
32149 PyObject * obj1 = 0 ;
32150 char * kwnames[] = {
32151 (char *) "self",(char *) "dir", NULL
32152 };
32153
32154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
32155 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32156 if (!SWIG_IsOK(res1)) {
32157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
32158 }
32159 arg1 = reinterpret_cast< wxWindow * >(argp1);
32160 if (obj1) {
32161 ecode2 = SWIG_AsVal_int(obj1, &val2);
32162 if (!SWIG_IsOK(ecode2)) {
32163 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
32164 }
32165 arg2 = static_cast< int >(val2);
32166 }
32167 {
32168 PyThreadState* __tstate = wxPyBeginAllowThreads();
32169 (arg1)->CenterOnParent(arg2);
32170 wxPyEndAllowThreads(__tstate);
32171 if (PyErr_Occurred()) SWIG_fail;
32172 }
32173 resultobj = SWIG_Py_Void();
32174 return resultobj;
32175 fail:
32176 return NULL;
32177 }
32178
32179
32180 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32181 PyObject *resultobj = 0;
32182 wxWindow *arg1 = (wxWindow *) 0 ;
32183 void *argp1 = 0 ;
32184 int res1 = 0 ;
32185 PyObject *swig_obj[1] ;
32186
32187 if (!args) SWIG_fail;
32188 swig_obj[0] = args;
32189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32190 if (!SWIG_IsOK(res1)) {
32191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
32192 }
32193 arg1 = reinterpret_cast< wxWindow * >(argp1);
32194 {
32195 PyThreadState* __tstate = wxPyBeginAllowThreads();
32196 (arg1)->Fit();
32197 wxPyEndAllowThreads(__tstate);
32198 if (PyErr_Occurred()) SWIG_fail;
32199 }
32200 resultobj = SWIG_Py_Void();
32201 return resultobj;
32202 fail:
32203 return NULL;
32204 }
32205
32206
32207 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32208 PyObject *resultobj = 0;
32209 wxWindow *arg1 = (wxWindow *) 0 ;
32210 void *argp1 = 0 ;
32211 int res1 = 0 ;
32212 PyObject *swig_obj[1] ;
32213
32214 if (!args) SWIG_fail;
32215 swig_obj[0] = args;
32216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32217 if (!SWIG_IsOK(res1)) {
32218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
32219 }
32220 arg1 = reinterpret_cast< wxWindow * >(argp1);
32221 {
32222 PyThreadState* __tstate = wxPyBeginAllowThreads();
32223 (arg1)->FitInside();
32224 wxPyEndAllowThreads(__tstate);
32225 if (PyErr_Occurred()) SWIG_fail;
32226 }
32227 resultobj = SWIG_Py_Void();
32228 return resultobj;
32229 fail:
32230 return NULL;
32231 }
32232
32233
32234 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32235 PyObject *resultobj = 0;
32236 wxWindow *arg1 = (wxWindow *) 0 ;
32237 int arg2 ;
32238 int arg3 ;
32239 int arg4 = (int) -1 ;
32240 int arg5 = (int) -1 ;
32241 int arg6 = (int) -1 ;
32242 int arg7 = (int) -1 ;
32243 void *argp1 = 0 ;
32244 int res1 = 0 ;
32245 int val2 ;
32246 int ecode2 = 0 ;
32247 int val3 ;
32248 int ecode3 = 0 ;
32249 int val4 ;
32250 int ecode4 = 0 ;
32251 int val5 ;
32252 int ecode5 = 0 ;
32253 int val6 ;
32254 int ecode6 = 0 ;
32255 int val7 ;
32256 int ecode7 = 0 ;
32257 PyObject * obj0 = 0 ;
32258 PyObject * obj1 = 0 ;
32259 PyObject * obj2 = 0 ;
32260 PyObject * obj3 = 0 ;
32261 PyObject * obj4 = 0 ;
32262 PyObject * obj5 = 0 ;
32263 PyObject * obj6 = 0 ;
32264 char * kwnames[] = {
32265 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
32266 };
32267
32268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
32269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32270 if (!SWIG_IsOK(res1)) {
32271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
32272 }
32273 arg1 = reinterpret_cast< wxWindow * >(argp1);
32274 ecode2 = SWIG_AsVal_int(obj1, &val2);
32275 if (!SWIG_IsOK(ecode2)) {
32276 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
32277 }
32278 arg2 = static_cast< int >(val2);
32279 ecode3 = SWIG_AsVal_int(obj2, &val3);
32280 if (!SWIG_IsOK(ecode3)) {
32281 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
32282 }
32283 arg3 = static_cast< int >(val3);
32284 if (obj3) {
32285 ecode4 = SWIG_AsVal_int(obj3, &val4);
32286 if (!SWIG_IsOK(ecode4)) {
32287 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
32288 }
32289 arg4 = static_cast< int >(val4);
32290 }
32291 if (obj4) {
32292 ecode5 = SWIG_AsVal_int(obj4, &val5);
32293 if (!SWIG_IsOK(ecode5)) {
32294 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
32295 }
32296 arg5 = static_cast< int >(val5);
32297 }
32298 if (obj5) {
32299 ecode6 = SWIG_AsVal_int(obj5, &val6);
32300 if (!SWIG_IsOK(ecode6)) {
32301 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
32302 }
32303 arg6 = static_cast< int >(val6);
32304 }
32305 if (obj6) {
32306 ecode7 = SWIG_AsVal_int(obj6, &val7);
32307 if (!SWIG_IsOK(ecode7)) {
32308 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
32309 }
32310 arg7 = static_cast< int >(val7);
32311 }
32312 {
32313 PyThreadState* __tstate = wxPyBeginAllowThreads();
32314 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
32315 wxPyEndAllowThreads(__tstate);
32316 if (PyErr_Occurred()) SWIG_fail;
32317 }
32318 resultobj = SWIG_Py_Void();
32319 return resultobj;
32320 fail:
32321 return NULL;
32322 }
32323
32324
32325 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32326 PyObject *resultobj = 0;
32327 wxWindow *arg1 = (wxWindow *) 0 ;
32328 wxSize *arg2 = 0 ;
32329 wxSize const &arg3_defvalue = wxDefaultSize ;
32330 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
32331 wxSize const &arg4_defvalue = wxDefaultSize ;
32332 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
32333 void *argp1 = 0 ;
32334 int res1 = 0 ;
32335 wxSize temp2 ;
32336 wxSize temp3 ;
32337 wxSize temp4 ;
32338 PyObject * obj0 = 0 ;
32339 PyObject * obj1 = 0 ;
32340 PyObject * obj2 = 0 ;
32341 PyObject * obj3 = 0 ;
32342 char * kwnames[] = {
32343 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
32344 };
32345
32346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32348 if (!SWIG_IsOK(res1)) {
32349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
32350 }
32351 arg1 = reinterpret_cast< wxWindow * >(argp1);
32352 {
32353 arg2 = &temp2;
32354 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32355 }
32356 if (obj2) {
32357 {
32358 arg3 = &temp3;
32359 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
32360 }
32361 }
32362 if (obj3) {
32363 {
32364 arg4 = &temp4;
32365 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
32366 }
32367 }
32368 {
32369 PyThreadState* __tstate = wxPyBeginAllowThreads();
32370 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
32371 wxPyEndAllowThreads(__tstate);
32372 if (PyErr_Occurred()) SWIG_fail;
32373 }
32374 resultobj = SWIG_Py_Void();
32375 return resultobj;
32376 fail:
32377 return NULL;
32378 }
32379
32380
32381 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32382 PyObject *resultobj = 0;
32383 wxWindow *arg1 = (wxWindow *) 0 ;
32384 int arg2 ;
32385 int arg3 ;
32386 int arg4 = (int) -1 ;
32387 int arg5 = (int) -1 ;
32388 void *argp1 = 0 ;
32389 int res1 = 0 ;
32390 int val2 ;
32391 int ecode2 = 0 ;
32392 int val3 ;
32393 int ecode3 = 0 ;
32394 int val4 ;
32395 int ecode4 = 0 ;
32396 int val5 ;
32397 int ecode5 = 0 ;
32398 PyObject * obj0 = 0 ;
32399 PyObject * obj1 = 0 ;
32400 PyObject * obj2 = 0 ;
32401 PyObject * obj3 = 0 ;
32402 PyObject * obj4 = 0 ;
32403 char * kwnames[] = {
32404 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
32405 };
32406
32407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
32408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32409 if (!SWIG_IsOK(res1)) {
32410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
32411 }
32412 arg1 = reinterpret_cast< wxWindow * >(argp1);
32413 ecode2 = SWIG_AsVal_int(obj1, &val2);
32414 if (!SWIG_IsOK(ecode2)) {
32415 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
32416 }
32417 arg2 = static_cast< int >(val2);
32418 ecode3 = SWIG_AsVal_int(obj2, &val3);
32419 if (!SWIG_IsOK(ecode3)) {
32420 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
32421 }
32422 arg3 = static_cast< int >(val3);
32423 if (obj3) {
32424 ecode4 = SWIG_AsVal_int(obj3, &val4);
32425 if (!SWIG_IsOK(ecode4)) {
32426 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
32427 }
32428 arg4 = static_cast< int >(val4);
32429 }
32430 if (obj4) {
32431 ecode5 = SWIG_AsVal_int(obj4, &val5);
32432 if (!SWIG_IsOK(ecode5)) {
32433 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
32434 }
32435 arg5 = static_cast< int >(val5);
32436 }
32437 {
32438 PyThreadState* __tstate = wxPyBeginAllowThreads();
32439 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
32440 wxPyEndAllowThreads(__tstate);
32441 if (PyErr_Occurred()) SWIG_fail;
32442 }
32443 resultobj = SWIG_Py_Void();
32444 return resultobj;
32445 fail:
32446 return NULL;
32447 }
32448
32449
32450 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32451 PyObject *resultobj = 0;
32452 wxWindow *arg1 = (wxWindow *) 0 ;
32453 wxSize *arg2 = 0 ;
32454 wxSize const &arg3_defvalue = wxDefaultSize ;
32455 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
32456 void *argp1 = 0 ;
32457 int res1 = 0 ;
32458 wxSize temp2 ;
32459 wxSize temp3 ;
32460 PyObject * obj0 = 0 ;
32461 PyObject * obj1 = 0 ;
32462 PyObject * obj2 = 0 ;
32463 char * kwnames[] = {
32464 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
32465 };
32466
32467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32469 if (!SWIG_IsOK(res1)) {
32470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
32471 }
32472 arg1 = reinterpret_cast< wxWindow * >(argp1);
32473 {
32474 arg2 = &temp2;
32475 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32476 }
32477 if (obj2) {
32478 {
32479 arg3 = &temp3;
32480 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
32481 }
32482 }
32483 {
32484 PyThreadState* __tstate = wxPyBeginAllowThreads();
32485 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
32486 wxPyEndAllowThreads(__tstate);
32487 if (PyErr_Occurred()) SWIG_fail;
32488 }
32489 resultobj = SWIG_Py_Void();
32490 return resultobj;
32491 fail:
32492 return NULL;
32493 }
32494
32495
32496 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32497 PyObject *resultobj = 0;
32498 wxWindow *arg1 = (wxWindow *) 0 ;
32499 wxSize result;
32500 void *argp1 = 0 ;
32501 int res1 = 0 ;
32502 PyObject *swig_obj[1] ;
32503
32504 if (!args) SWIG_fail;
32505 swig_obj[0] = args;
32506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32507 if (!SWIG_IsOK(res1)) {
32508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32509 }
32510 arg1 = reinterpret_cast< wxWindow * >(argp1);
32511 {
32512 PyThreadState* __tstate = wxPyBeginAllowThreads();
32513 result = ((wxWindow const *)arg1)->GetMaxSize();
32514 wxPyEndAllowThreads(__tstate);
32515 if (PyErr_Occurred()) SWIG_fail;
32516 }
32517 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32518 return resultobj;
32519 fail:
32520 return NULL;
32521 }
32522
32523
32524 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32525 PyObject *resultobj = 0;
32526 wxWindow *arg1 = (wxWindow *) 0 ;
32527 wxSize result;
32528 void *argp1 = 0 ;
32529 int res1 = 0 ;
32530 PyObject *swig_obj[1] ;
32531
32532 if (!args) SWIG_fail;
32533 swig_obj[0] = args;
32534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32535 if (!SWIG_IsOK(res1)) {
32536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32537 }
32538 arg1 = reinterpret_cast< wxWindow * >(argp1);
32539 {
32540 PyThreadState* __tstate = wxPyBeginAllowThreads();
32541 result = ((wxWindow const *)arg1)->GetMinSize();
32542 wxPyEndAllowThreads(__tstate);
32543 if (PyErr_Occurred()) SWIG_fail;
32544 }
32545 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32546 return resultobj;
32547 fail:
32548 return NULL;
32549 }
32550
32551
32552 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32553 PyObject *resultobj = 0;
32554 wxWindow *arg1 = (wxWindow *) 0 ;
32555 wxSize *arg2 = 0 ;
32556 void *argp1 = 0 ;
32557 int res1 = 0 ;
32558 wxSize temp2 ;
32559 PyObject * obj0 = 0 ;
32560 PyObject * obj1 = 0 ;
32561 char * kwnames[] = {
32562 (char *) "self",(char *) "minSize", NULL
32563 };
32564
32565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
32566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32567 if (!SWIG_IsOK(res1)) {
32568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32569 }
32570 arg1 = reinterpret_cast< wxWindow * >(argp1);
32571 {
32572 arg2 = &temp2;
32573 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32574 }
32575 {
32576 PyThreadState* __tstate = wxPyBeginAllowThreads();
32577 (arg1)->SetMinSize((wxSize const &)*arg2);
32578 wxPyEndAllowThreads(__tstate);
32579 if (PyErr_Occurred()) SWIG_fail;
32580 }
32581 resultobj = SWIG_Py_Void();
32582 return resultobj;
32583 fail:
32584 return NULL;
32585 }
32586
32587
32588 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32589 PyObject *resultobj = 0;
32590 wxWindow *arg1 = (wxWindow *) 0 ;
32591 wxSize *arg2 = 0 ;
32592 void *argp1 = 0 ;
32593 int res1 = 0 ;
32594 wxSize temp2 ;
32595 PyObject * obj0 = 0 ;
32596 PyObject * obj1 = 0 ;
32597 char * kwnames[] = {
32598 (char *) "self",(char *) "maxSize", NULL
32599 };
32600
32601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
32602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32603 if (!SWIG_IsOK(res1)) {
32604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32605 }
32606 arg1 = reinterpret_cast< wxWindow * >(argp1);
32607 {
32608 arg2 = &temp2;
32609 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32610 }
32611 {
32612 PyThreadState* __tstate = wxPyBeginAllowThreads();
32613 (arg1)->SetMaxSize((wxSize const &)*arg2);
32614 wxPyEndAllowThreads(__tstate);
32615 if (PyErr_Occurred()) SWIG_fail;
32616 }
32617 resultobj = SWIG_Py_Void();
32618 return resultobj;
32619 fail:
32620 return NULL;
32621 }
32622
32623
32624 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32625 PyObject *resultobj = 0;
32626 wxWindow *arg1 = (wxWindow *) 0 ;
32627 int result;
32628 void *argp1 = 0 ;
32629 int res1 = 0 ;
32630 PyObject *swig_obj[1] ;
32631
32632 if (!args) SWIG_fail;
32633 swig_obj[0] = args;
32634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32635 if (!SWIG_IsOK(res1)) {
32636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
32637 }
32638 arg1 = reinterpret_cast< wxWindow * >(argp1);
32639 {
32640 PyThreadState* __tstate = wxPyBeginAllowThreads();
32641 result = (int)((wxWindow const *)arg1)->GetMinWidth();
32642 wxPyEndAllowThreads(__tstate);
32643 if (PyErr_Occurred()) SWIG_fail;
32644 }
32645 resultobj = SWIG_From_int(static_cast< int >(result));
32646 return resultobj;
32647 fail:
32648 return NULL;
32649 }
32650
32651
32652 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32653 PyObject *resultobj = 0;
32654 wxWindow *arg1 = (wxWindow *) 0 ;
32655 int result;
32656 void *argp1 = 0 ;
32657 int res1 = 0 ;
32658 PyObject *swig_obj[1] ;
32659
32660 if (!args) SWIG_fail;
32661 swig_obj[0] = args;
32662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32663 if (!SWIG_IsOK(res1)) {
32664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
32665 }
32666 arg1 = reinterpret_cast< wxWindow * >(argp1);
32667 {
32668 PyThreadState* __tstate = wxPyBeginAllowThreads();
32669 result = (int)((wxWindow const *)arg1)->GetMinHeight();
32670 wxPyEndAllowThreads(__tstate);
32671 if (PyErr_Occurred()) SWIG_fail;
32672 }
32673 resultobj = SWIG_From_int(static_cast< int >(result));
32674 return resultobj;
32675 fail:
32676 return NULL;
32677 }
32678
32679
32680 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32681 PyObject *resultobj = 0;
32682 wxWindow *arg1 = (wxWindow *) 0 ;
32683 int result;
32684 void *argp1 = 0 ;
32685 int res1 = 0 ;
32686 PyObject *swig_obj[1] ;
32687
32688 if (!args) SWIG_fail;
32689 swig_obj[0] = args;
32690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32691 if (!SWIG_IsOK(res1)) {
32692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
32693 }
32694 arg1 = reinterpret_cast< wxWindow * >(argp1);
32695 {
32696 PyThreadState* __tstate = wxPyBeginAllowThreads();
32697 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
32698 wxPyEndAllowThreads(__tstate);
32699 if (PyErr_Occurred()) SWIG_fail;
32700 }
32701 resultobj = SWIG_From_int(static_cast< int >(result));
32702 return resultobj;
32703 fail:
32704 return NULL;
32705 }
32706
32707
32708 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32709 PyObject *resultobj = 0;
32710 wxWindow *arg1 = (wxWindow *) 0 ;
32711 int result;
32712 void *argp1 = 0 ;
32713 int res1 = 0 ;
32714 PyObject *swig_obj[1] ;
32715
32716 if (!args) SWIG_fail;
32717 swig_obj[0] = args;
32718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32719 if (!SWIG_IsOK(res1)) {
32720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
32721 }
32722 arg1 = reinterpret_cast< wxWindow * >(argp1);
32723 {
32724 PyThreadState* __tstate = wxPyBeginAllowThreads();
32725 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
32726 wxPyEndAllowThreads(__tstate);
32727 if (PyErr_Occurred()) SWIG_fail;
32728 }
32729 resultobj = SWIG_From_int(static_cast< int >(result));
32730 return resultobj;
32731 fail:
32732 return NULL;
32733 }
32734
32735
32736 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32737 PyObject *resultobj = 0;
32738 wxWindow *arg1 = (wxWindow *) 0 ;
32739 wxSize *arg2 = 0 ;
32740 void *argp1 = 0 ;
32741 int res1 = 0 ;
32742 wxSize temp2 ;
32743 PyObject * obj0 = 0 ;
32744 PyObject * obj1 = 0 ;
32745 char * kwnames[] = {
32746 (char *) "self",(char *) "size", NULL
32747 };
32748
32749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
32750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32751 if (!SWIG_IsOK(res1)) {
32752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32753 }
32754 arg1 = reinterpret_cast< wxWindow * >(argp1);
32755 {
32756 arg2 = &temp2;
32757 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32758 }
32759 {
32760 PyThreadState* __tstate = wxPyBeginAllowThreads();
32761 (arg1)->SetVirtualSize((wxSize const &)*arg2);
32762 wxPyEndAllowThreads(__tstate);
32763 if (PyErr_Occurred()) SWIG_fail;
32764 }
32765 resultobj = SWIG_Py_Void();
32766 return resultobj;
32767 fail:
32768 return NULL;
32769 }
32770
32771
32772 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32773 PyObject *resultobj = 0;
32774 wxWindow *arg1 = (wxWindow *) 0 ;
32775 int arg2 ;
32776 int arg3 ;
32777 void *argp1 = 0 ;
32778 int res1 = 0 ;
32779 int val2 ;
32780 int ecode2 = 0 ;
32781 int val3 ;
32782 int ecode3 = 0 ;
32783 PyObject * obj0 = 0 ;
32784 PyObject * obj1 = 0 ;
32785 PyObject * obj2 = 0 ;
32786 char * kwnames[] = {
32787 (char *) "self",(char *) "w",(char *) "h", NULL
32788 };
32789
32790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32792 if (!SWIG_IsOK(res1)) {
32793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
32794 }
32795 arg1 = reinterpret_cast< wxWindow * >(argp1);
32796 ecode2 = SWIG_AsVal_int(obj1, &val2);
32797 if (!SWIG_IsOK(ecode2)) {
32798 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
32799 }
32800 arg2 = static_cast< int >(val2);
32801 ecode3 = SWIG_AsVal_int(obj2, &val3);
32802 if (!SWIG_IsOK(ecode3)) {
32803 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
32804 }
32805 arg3 = static_cast< int >(val3);
32806 {
32807 PyThreadState* __tstate = wxPyBeginAllowThreads();
32808 (arg1)->SetVirtualSize(arg2,arg3);
32809 wxPyEndAllowThreads(__tstate);
32810 if (PyErr_Occurred()) SWIG_fail;
32811 }
32812 resultobj = SWIG_Py_Void();
32813 return resultobj;
32814 fail:
32815 return NULL;
32816 }
32817
32818
32819 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32820 PyObject *resultobj = 0;
32821 wxWindow *arg1 = (wxWindow *) 0 ;
32822 wxSize result;
32823 void *argp1 = 0 ;
32824 int res1 = 0 ;
32825 PyObject *swig_obj[1] ;
32826
32827 if (!args) SWIG_fail;
32828 swig_obj[0] = args;
32829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32830 if (!SWIG_IsOK(res1)) {
32831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32832 }
32833 arg1 = reinterpret_cast< wxWindow * >(argp1);
32834 {
32835 PyThreadState* __tstate = wxPyBeginAllowThreads();
32836 result = ((wxWindow const *)arg1)->GetVirtualSize();
32837 wxPyEndAllowThreads(__tstate);
32838 if (PyErr_Occurred()) SWIG_fail;
32839 }
32840 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32841 return resultobj;
32842 fail:
32843 return NULL;
32844 }
32845
32846
32847 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32848 PyObject *resultobj = 0;
32849 wxWindow *arg1 = (wxWindow *) 0 ;
32850 int *arg2 = (int *) 0 ;
32851 int *arg3 = (int *) 0 ;
32852 void *argp1 = 0 ;
32853 int res1 = 0 ;
32854 int temp2 ;
32855 int res2 = SWIG_TMPOBJ ;
32856 int temp3 ;
32857 int res3 = SWIG_TMPOBJ ;
32858 PyObject *swig_obj[1] ;
32859
32860 arg2 = &temp2;
32861 arg3 = &temp3;
32862 if (!args) SWIG_fail;
32863 swig_obj[0] = args;
32864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32865 if (!SWIG_IsOK(res1)) {
32866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32867 }
32868 arg1 = reinterpret_cast< wxWindow * >(argp1);
32869 {
32870 PyThreadState* __tstate = wxPyBeginAllowThreads();
32871 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
32872 wxPyEndAllowThreads(__tstate);
32873 if (PyErr_Occurred()) SWIG_fail;
32874 }
32875 resultobj = SWIG_Py_Void();
32876 if (SWIG_IsTmpObj(res2)) {
32877 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32878 } else {
32879 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32880 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32881 }
32882 if (SWIG_IsTmpObj(res3)) {
32883 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32884 } else {
32885 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32886 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32887 }
32888 return resultobj;
32889 fail:
32890 return NULL;
32891 }
32892
32893
32894 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32895 PyObject *resultobj = 0;
32896 wxWindow *arg1 = (wxWindow *) 0 ;
32897 wxSize result;
32898 void *argp1 = 0 ;
32899 int res1 = 0 ;
32900 PyObject *swig_obj[1] ;
32901
32902 if (!args) SWIG_fail;
32903 swig_obj[0] = args;
32904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32905 if (!SWIG_IsOK(res1)) {
32906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32907 }
32908 arg1 = reinterpret_cast< wxWindow * >(argp1);
32909 {
32910 PyThreadState* __tstate = wxPyBeginAllowThreads();
32911 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
32912 wxPyEndAllowThreads(__tstate);
32913 if (PyErr_Occurred()) SWIG_fail;
32914 }
32915 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32916 return resultobj;
32917 fail:
32918 return NULL;
32919 }
32920
32921
32922 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32923 PyObject *resultobj = 0;
32924 wxWindow *arg1 = (wxWindow *) 0 ;
32925 bool arg2 = (bool) true ;
32926 bool result;
32927 void *argp1 = 0 ;
32928 int res1 = 0 ;
32929 bool val2 ;
32930 int ecode2 = 0 ;
32931 PyObject * obj0 = 0 ;
32932 PyObject * obj1 = 0 ;
32933 char * kwnames[] = {
32934 (char *) "self",(char *) "show", NULL
32935 };
32936
32937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
32938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32939 if (!SWIG_IsOK(res1)) {
32940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
32941 }
32942 arg1 = reinterpret_cast< wxWindow * >(argp1);
32943 if (obj1) {
32944 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32945 if (!SWIG_IsOK(ecode2)) {
32946 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
32947 }
32948 arg2 = static_cast< bool >(val2);
32949 }
32950 {
32951 PyThreadState* __tstate = wxPyBeginAllowThreads();
32952 result = (bool)(arg1)->Show(arg2);
32953 wxPyEndAllowThreads(__tstate);
32954 if (PyErr_Occurred()) SWIG_fail;
32955 }
32956 {
32957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32958 }
32959 return resultobj;
32960 fail:
32961 return NULL;
32962 }
32963
32964
32965 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32966 PyObject *resultobj = 0;
32967 wxWindow *arg1 = (wxWindow *) 0 ;
32968 bool result;
32969 void *argp1 = 0 ;
32970 int res1 = 0 ;
32971 PyObject *swig_obj[1] ;
32972
32973 if (!args) SWIG_fail;
32974 swig_obj[0] = args;
32975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32976 if (!SWIG_IsOK(res1)) {
32977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
32978 }
32979 arg1 = reinterpret_cast< wxWindow * >(argp1);
32980 {
32981 PyThreadState* __tstate = wxPyBeginAllowThreads();
32982 result = (bool)(arg1)->Hide();
32983 wxPyEndAllowThreads(__tstate);
32984 if (PyErr_Occurred()) SWIG_fail;
32985 }
32986 {
32987 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32988 }
32989 return resultobj;
32990 fail:
32991 return NULL;
32992 }
32993
32994
32995 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32996 PyObject *resultobj = 0;
32997 wxWindow *arg1 = (wxWindow *) 0 ;
32998 bool arg2 = (bool) true ;
32999 bool result;
33000 void *argp1 = 0 ;
33001 int res1 = 0 ;
33002 bool val2 ;
33003 int ecode2 = 0 ;
33004 PyObject * obj0 = 0 ;
33005 PyObject * obj1 = 0 ;
33006 char * kwnames[] = {
33007 (char *) "self",(char *) "enable", NULL
33008 };
33009
33010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
33011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33012 if (!SWIG_IsOK(res1)) {
33013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
33014 }
33015 arg1 = reinterpret_cast< wxWindow * >(argp1);
33016 if (obj1) {
33017 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33018 if (!SWIG_IsOK(ecode2)) {
33019 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
33020 }
33021 arg2 = static_cast< bool >(val2);
33022 }
33023 {
33024 PyThreadState* __tstate = wxPyBeginAllowThreads();
33025 result = (bool)(arg1)->Enable(arg2);
33026 wxPyEndAllowThreads(__tstate);
33027 if (PyErr_Occurred()) SWIG_fail;
33028 }
33029 {
33030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33031 }
33032 return resultobj;
33033 fail:
33034 return NULL;
33035 }
33036
33037
33038 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33039 PyObject *resultobj = 0;
33040 wxWindow *arg1 = (wxWindow *) 0 ;
33041 bool result;
33042 void *argp1 = 0 ;
33043 int res1 = 0 ;
33044 PyObject *swig_obj[1] ;
33045
33046 if (!args) SWIG_fail;
33047 swig_obj[0] = args;
33048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33049 if (!SWIG_IsOK(res1)) {
33050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
33051 }
33052 arg1 = reinterpret_cast< wxWindow * >(argp1);
33053 {
33054 PyThreadState* __tstate = wxPyBeginAllowThreads();
33055 result = (bool)(arg1)->Disable();
33056 wxPyEndAllowThreads(__tstate);
33057 if (PyErr_Occurred()) SWIG_fail;
33058 }
33059 {
33060 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33061 }
33062 return resultobj;
33063 fail:
33064 return NULL;
33065 }
33066
33067
33068 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33069 PyObject *resultobj = 0;
33070 wxWindow *arg1 = (wxWindow *) 0 ;
33071 bool result;
33072 void *argp1 = 0 ;
33073 int res1 = 0 ;
33074 PyObject *swig_obj[1] ;
33075
33076 if (!args) SWIG_fail;
33077 swig_obj[0] = args;
33078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33079 if (!SWIG_IsOK(res1)) {
33080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
33081 }
33082 arg1 = reinterpret_cast< wxWindow * >(argp1);
33083 {
33084 PyThreadState* __tstate = wxPyBeginAllowThreads();
33085 result = (bool)((wxWindow const *)arg1)->IsShown();
33086 wxPyEndAllowThreads(__tstate);
33087 if (PyErr_Occurred()) SWIG_fail;
33088 }
33089 {
33090 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33091 }
33092 return resultobj;
33093 fail:
33094 return NULL;
33095 }
33096
33097
33098 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33099 PyObject *resultobj = 0;
33100 wxWindow *arg1 = (wxWindow *) 0 ;
33101 bool result;
33102 void *argp1 = 0 ;
33103 int res1 = 0 ;
33104 PyObject *swig_obj[1] ;
33105
33106 if (!args) SWIG_fail;
33107 swig_obj[0] = args;
33108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33109 if (!SWIG_IsOK(res1)) {
33110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
33111 }
33112 arg1 = reinterpret_cast< wxWindow * >(argp1);
33113 {
33114 PyThreadState* __tstate = wxPyBeginAllowThreads();
33115 result = (bool)((wxWindow const *)arg1)->IsEnabled();
33116 wxPyEndAllowThreads(__tstate);
33117 if (PyErr_Occurred()) SWIG_fail;
33118 }
33119 {
33120 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33121 }
33122 return resultobj;
33123 fail:
33124 return NULL;
33125 }
33126
33127
33128 SWIGINTERN PyObject *_wrap_Window_IsShownOnScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33129 PyObject *resultobj = 0;
33130 wxWindow *arg1 = (wxWindow *) 0 ;
33131 bool result;
33132 void *argp1 = 0 ;
33133 int res1 = 0 ;
33134 PyObject *swig_obj[1] ;
33135
33136 if (!args) SWIG_fail;
33137 swig_obj[0] = args;
33138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33139 if (!SWIG_IsOK(res1)) {
33140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShownOnScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
33141 }
33142 arg1 = reinterpret_cast< wxWindow * >(argp1);
33143 {
33144 PyThreadState* __tstate = wxPyBeginAllowThreads();
33145 result = (bool)((wxWindow const *)arg1)->IsShownOnScreen();
33146 wxPyEndAllowThreads(__tstate);
33147 if (PyErr_Occurred()) SWIG_fail;
33148 }
33149 {
33150 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33151 }
33152 return resultobj;
33153 fail:
33154 return NULL;
33155 }
33156
33157
33158 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33159 PyObject *resultobj = 0;
33160 wxWindow *arg1 = (wxWindow *) 0 ;
33161 long arg2 ;
33162 void *argp1 = 0 ;
33163 int res1 = 0 ;
33164 long val2 ;
33165 int ecode2 = 0 ;
33166 PyObject * obj0 = 0 ;
33167 PyObject * obj1 = 0 ;
33168 char * kwnames[] = {
33169 (char *) "self",(char *) "style", NULL
33170 };
33171
33172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
33173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33174 if (!SWIG_IsOK(res1)) {
33175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
33176 }
33177 arg1 = reinterpret_cast< wxWindow * >(argp1);
33178 ecode2 = SWIG_AsVal_long(obj1, &val2);
33179 if (!SWIG_IsOK(ecode2)) {
33180 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
33181 }
33182 arg2 = static_cast< long >(val2);
33183 {
33184 PyThreadState* __tstate = wxPyBeginAllowThreads();
33185 (arg1)->SetWindowStyleFlag(arg2);
33186 wxPyEndAllowThreads(__tstate);
33187 if (PyErr_Occurred()) SWIG_fail;
33188 }
33189 resultobj = SWIG_Py_Void();
33190 return resultobj;
33191 fail:
33192 return NULL;
33193 }
33194
33195
33196 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33197 PyObject *resultobj = 0;
33198 wxWindow *arg1 = (wxWindow *) 0 ;
33199 long result;
33200 void *argp1 = 0 ;
33201 int res1 = 0 ;
33202 PyObject *swig_obj[1] ;
33203
33204 if (!args) SWIG_fail;
33205 swig_obj[0] = args;
33206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33207 if (!SWIG_IsOK(res1)) {
33208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
33209 }
33210 arg1 = reinterpret_cast< wxWindow * >(argp1);
33211 {
33212 PyThreadState* __tstate = wxPyBeginAllowThreads();
33213 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
33214 wxPyEndAllowThreads(__tstate);
33215 if (PyErr_Occurred()) SWIG_fail;
33216 }
33217 resultobj = SWIG_From_long(static_cast< long >(result));
33218 return resultobj;
33219 fail:
33220 return NULL;
33221 }
33222
33223
33224 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33225 PyObject *resultobj = 0;
33226 wxWindow *arg1 = (wxWindow *) 0 ;
33227 int arg2 ;
33228 bool result;
33229 void *argp1 = 0 ;
33230 int res1 = 0 ;
33231 int val2 ;
33232 int ecode2 = 0 ;
33233 PyObject * obj0 = 0 ;
33234 PyObject * obj1 = 0 ;
33235 char * kwnames[] = {
33236 (char *) "self",(char *) "flag", NULL
33237 };
33238
33239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
33240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33241 if (!SWIG_IsOK(res1)) {
33242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
33243 }
33244 arg1 = reinterpret_cast< wxWindow * >(argp1);
33245 ecode2 = SWIG_AsVal_int(obj1, &val2);
33246 if (!SWIG_IsOK(ecode2)) {
33247 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
33248 }
33249 arg2 = static_cast< int >(val2);
33250 {
33251 PyThreadState* __tstate = wxPyBeginAllowThreads();
33252 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
33253 wxPyEndAllowThreads(__tstate);
33254 if (PyErr_Occurred()) SWIG_fail;
33255 }
33256 {
33257 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33258 }
33259 return resultobj;
33260 fail:
33261 return NULL;
33262 }
33263
33264
33265 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33266 PyObject *resultobj = 0;
33267 wxWindow *arg1 = (wxWindow *) 0 ;
33268 bool result;
33269 void *argp1 = 0 ;
33270 int res1 = 0 ;
33271 PyObject *swig_obj[1] ;
33272
33273 if (!args) SWIG_fail;
33274 swig_obj[0] = args;
33275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33276 if (!SWIG_IsOK(res1)) {
33277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
33278 }
33279 arg1 = reinterpret_cast< wxWindow * >(argp1);
33280 {
33281 PyThreadState* __tstate = wxPyBeginAllowThreads();
33282 result = (bool)((wxWindow const *)arg1)->IsRetained();
33283 wxPyEndAllowThreads(__tstate);
33284 if (PyErr_Occurred()) SWIG_fail;
33285 }
33286 {
33287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33288 }
33289 return resultobj;
33290 fail:
33291 return NULL;
33292 }
33293
33294
33295 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33296 PyObject *resultobj = 0;
33297 wxWindow *arg1 = (wxWindow *) 0 ;
33298 long arg2 ;
33299 void *argp1 = 0 ;
33300 int res1 = 0 ;
33301 long val2 ;
33302 int ecode2 = 0 ;
33303 PyObject * obj0 = 0 ;
33304 PyObject * obj1 = 0 ;
33305 char * kwnames[] = {
33306 (char *) "self",(char *) "exStyle", NULL
33307 };
33308
33309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
33310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33311 if (!SWIG_IsOK(res1)) {
33312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
33313 }
33314 arg1 = reinterpret_cast< wxWindow * >(argp1);
33315 ecode2 = SWIG_AsVal_long(obj1, &val2);
33316 if (!SWIG_IsOK(ecode2)) {
33317 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
33318 }
33319 arg2 = static_cast< long >(val2);
33320 {
33321 PyThreadState* __tstate = wxPyBeginAllowThreads();
33322 (arg1)->SetExtraStyle(arg2);
33323 wxPyEndAllowThreads(__tstate);
33324 if (PyErr_Occurred()) SWIG_fail;
33325 }
33326 resultobj = SWIG_Py_Void();
33327 return resultobj;
33328 fail:
33329 return NULL;
33330 }
33331
33332
33333 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33334 PyObject *resultobj = 0;
33335 wxWindow *arg1 = (wxWindow *) 0 ;
33336 long result;
33337 void *argp1 = 0 ;
33338 int res1 = 0 ;
33339 PyObject *swig_obj[1] ;
33340
33341 if (!args) SWIG_fail;
33342 swig_obj[0] = args;
33343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33344 if (!SWIG_IsOK(res1)) {
33345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
33346 }
33347 arg1 = reinterpret_cast< wxWindow * >(argp1);
33348 {
33349 PyThreadState* __tstate = wxPyBeginAllowThreads();
33350 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
33351 wxPyEndAllowThreads(__tstate);
33352 if (PyErr_Occurred()) SWIG_fail;
33353 }
33354 resultobj = SWIG_From_long(static_cast< long >(result));
33355 return resultobj;
33356 fail:
33357 return NULL;
33358 }
33359
33360
33361 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33362 PyObject *resultobj = 0;
33363 wxWindow *arg1 = (wxWindow *) 0 ;
33364 bool arg2 = (bool) true ;
33365 void *argp1 = 0 ;
33366 int res1 = 0 ;
33367 bool val2 ;
33368 int ecode2 = 0 ;
33369 PyObject * obj0 = 0 ;
33370 PyObject * obj1 = 0 ;
33371 char * kwnames[] = {
33372 (char *) "self",(char *) "modal", NULL
33373 };
33374
33375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
33376 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33377 if (!SWIG_IsOK(res1)) {
33378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
33379 }
33380 arg1 = reinterpret_cast< wxWindow * >(argp1);
33381 if (obj1) {
33382 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33383 if (!SWIG_IsOK(ecode2)) {
33384 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
33385 }
33386 arg2 = static_cast< bool >(val2);
33387 }
33388 {
33389 PyThreadState* __tstate = wxPyBeginAllowThreads();
33390 (arg1)->MakeModal(arg2);
33391 wxPyEndAllowThreads(__tstate);
33392 if (PyErr_Occurred()) SWIG_fail;
33393 }
33394 resultobj = SWIG_Py_Void();
33395 return resultobj;
33396 fail:
33397 return NULL;
33398 }
33399
33400
33401 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33402 PyObject *resultobj = 0;
33403 wxWindow *arg1 = (wxWindow *) 0 ;
33404 bool arg2 ;
33405 void *argp1 = 0 ;
33406 int res1 = 0 ;
33407 bool val2 ;
33408 int ecode2 = 0 ;
33409 PyObject * obj0 = 0 ;
33410 PyObject * obj1 = 0 ;
33411 char * kwnames[] = {
33412 (char *) "self",(char *) "enableTheme", NULL
33413 };
33414
33415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
33416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33417 if (!SWIG_IsOK(res1)) {
33418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
33419 }
33420 arg1 = reinterpret_cast< wxWindow * >(argp1);
33421 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33422 if (!SWIG_IsOK(ecode2)) {
33423 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
33424 }
33425 arg2 = static_cast< bool >(val2);
33426 {
33427 PyThreadState* __tstate = wxPyBeginAllowThreads();
33428 (arg1)->SetThemeEnabled(arg2);
33429 wxPyEndAllowThreads(__tstate);
33430 if (PyErr_Occurred()) SWIG_fail;
33431 }
33432 resultobj = SWIG_Py_Void();
33433 return resultobj;
33434 fail:
33435 return NULL;
33436 }
33437
33438
33439 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33440 PyObject *resultobj = 0;
33441 wxWindow *arg1 = (wxWindow *) 0 ;
33442 bool result;
33443 void *argp1 = 0 ;
33444 int res1 = 0 ;
33445 PyObject *swig_obj[1] ;
33446
33447 if (!args) SWIG_fail;
33448 swig_obj[0] = args;
33449 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33450 if (!SWIG_IsOK(res1)) {
33451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
33452 }
33453 arg1 = reinterpret_cast< wxWindow * >(argp1);
33454 {
33455 PyThreadState* __tstate = wxPyBeginAllowThreads();
33456 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
33457 wxPyEndAllowThreads(__tstate);
33458 if (PyErr_Occurred()) SWIG_fail;
33459 }
33460 {
33461 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33462 }
33463 return resultobj;
33464 fail:
33465 return NULL;
33466 }
33467
33468
33469 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33470 PyObject *resultobj = 0;
33471 wxWindow *arg1 = (wxWindow *) 0 ;
33472 void *argp1 = 0 ;
33473 int res1 = 0 ;
33474 PyObject *swig_obj[1] ;
33475
33476 if (!args) SWIG_fail;
33477 swig_obj[0] = args;
33478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33479 if (!SWIG_IsOK(res1)) {
33480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
33481 }
33482 arg1 = reinterpret_cast< wxWindow * >(argp1);
33483 {
33484 PyThreadState* __tstate = wxPyBeginAllowThreads();
33485 (arg1)->SetFocus();
33486 wxPyEndAllowThreads(__tstate);
33487 if (PyErr_Occurred()) SWIG_fail;
33488 }
33489 resultobj = SWIG_Py_Void();
33490 return resultobj;
33491 fail:
33492 return NULL;
33493 }
33494
33495
33496 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33497 PyObject *resultobj = 0;
33498 wxWindow *arg1 = (wxWindow *) 0 ;
33499 void *argp1 = 0 ;
33500 int res1 = 0 ;
33501 PyObject *swig_obj[1] ;
33502
33503 if (!args) SWIG_fail;
33504 swig_obj[0] = args;
33505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33506 if (!SWIG_IsOK(res1)) {
33507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
33508 }
33509 arg1 = reinterpret_cast< wxWindow * >(argp1);
33510 {
33511 PyThreadState* __tstate = wxPyBeginAllowThreads();
33512 (arg1)->SetFocusFromKbd();
33513 wxPyEndAllowThreads(__tstate);
33514 if (PyErr_Occurred()) SWIG_fail;
33515 }
33516 resultobj = SWIG_Py_Void();
33517 return resultobj;
33518 fail:
33519 return NULL;
33520 }
33521
33522
33523 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33524 PyObject *resultobj = 0;
33525 wxWindow *result = 0 ;
33526
33527 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
33528 {
33529 if (!wxPyCheckForApp()) SWIG_fail;
33530 PyThreadState* __tstate = wxPyBeginAllowThreads();
33531 result = (wxWindow *)wxWindow::FindFocus();
33532 wxPyEndAllowThreads(__tstate);
33533 if (PyErr_Occurred()) SWIG_fail;
33534 }
33535 {
33536 resultobj = wxPyMake_wxObject(result, 0);
33537 }
33538 return resultobj;
33539 fail:
33540 return NULL;
33541 }
33542
33543
33544 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33545 PyObject *resultobj = 0;
33546 wxWindow *arg1 = (wxWindow *) 0 ;
33547 bool result;
33548 void *argp1 = 0 ;
33549 int res1 = 0 ;
33550 PyObject *swig_obj[1] ;
33551
33552 if (!args) SWIG_fail;
33553 swig_obj[0] = args;
33554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33555 if (!SWIG_IsOK(res1)) {
33556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
33557 }
33558 arg1 = reinterpret_cast< wxWindow * >(argp1);
33559 {
33560 PyThreadState* __tstate = wxPyBeginAllowThreads();
33561 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
33562 wxPyEndAllowThreads(__tstate);
33563 if (PyErr_Occurred()) SWIG_fail;
33564 }
33565 {
33566 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33567 }
33568 return resultobj;
33569 fail:
33570 return NULL;
33571 }
33572
33573
33574 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33575 PyObject *resultobj = 0;
33576 wxWindow *arg1 = (wxWindow *) 0 ;
33577 bool result;
33578 void *argp1 = 0 ;
33579 int res1 = 0 ;
33580 PyObject *swig_obj[1] ;
33581
33582 if (!args) SWIG_fail;
33583 swig_obj[0] = args;
33584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33585 if (!SWIG_IsOK(res1)) {
33586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
33587 }
33588 arg1 = reinterpret_cast< wxWindow * >(argp1);
33589 {
33590 PyThreadState* __tstate = wxPyBeginAllowThreads();
33591 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
33592 wxPyEndAllowThreads(__tstate);
33593 if (PyErr_Occurred()) SWIG_fail;
33594 }
33595 {
33596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33597 }
33598 return resultobj;
33599 fail:
33600 return NULL;
33601 }
33602
33603
33604 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33605 PyObject *resultobj = 0;
33606 wxWindow *arg1 = (wxWindow *) 0 ;
33607 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
33608 bool result;
33609 void *argp1 = 0 ;
33610 int res1 = 0 ;
33611 int val2 ;
33612 int ecode2 = 0 ;
33613 PyObject * obj0 = 0 ;
33614 PyObject * obj1 = 0 ;
33615 char * kwnames[] = {
33616 (char *) "self",(char *) "flags", NULL
33617 };
33618
33619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
33620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33621 if (!SWIG_IsOK(res1)) {
33622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
33623 }
33624 arg1 = reinterpret_cast< wxWindow * >(argp1);
33625 if (obj1) {
33626 ecode2 = SWIG_AsVal_int(obj1, &val2);
33627 if (!SWIG_IsOK(ecode2)) {
33628 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
33629 }
33630 arg2 = static_cast< int >(val2);
33631 }
33632 {
33633 PyThreadState* __tstate = wxPyBeginAllowThreads();
33634 result = (bool)(arg1)->Navigate(arg2);
33635 wxPyEndAllowThreads(__tstate);
33636 if (PyErr_Occurred()) SWIG_fail;
33637 }
33638 {
33639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33640 }
33641 return resultobj;
33642 fail:
33643 return NULL;
33644 }
33645
33646
33647 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33648 PyObject *resultobj = 0;
33649 wxWindow *arg1 = (wxWindow *) 0 ;
33650 wxWindow *arg2 = (wxWindow *) 0 ;
33651 void *argp1 = 0 ;
33652 int res1 = 0 ;
33653 void *argp2 = 0 ;
33654 int res2 = 0 ;
33655 PyObject * obj0 = 0 ;
33656 PyObject * obj1 = 0 ;
33657 char * kwnames[] = {
33658 (char *) "self",(char *) "win", NULL
33659 };
33660
33661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33663 if (!SWIG_IsOK(res1)) {
33664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33665 }
33666 arg1 = reinterpret_cast< wxWindow * >(argp1);
33667 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33668 if (!SWIG_IsOK(res2)) {
33669 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33670 }
33671 arg2 = reinterpret_cast< wxWindow * >(argp2);
33672 {
33673 PyThreadState* __tstate = wxPyBeginAllowThreads();
33674 (arg1)->MoveAfterInTabOrder(arg2);
33675 wxPyEndAllowThreads(__tstate);
33676 if (PyErr_Occurred()) SWIG_fail;
33677 }
33678 resultobj = SWIG_Py_Void();
33679 return resultobj;
33680 fail:
33681 return NULL;
33682 }
33683
33684
33685 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33686 PyObject *resultobj = 0;
33687 wxWindow *arg1 = (wxWindow *) 0 ;
33688 wxWindow *arg2 = (wxWindow *) 0 ;
33689 void *argp1 = 0 ;
33690 int res1 = 0 ;
33691 void *argp2 = 0 ;
33692 int res2 = 0 ;
33693 PyObject * obj0 = 0 ;
33694 PyObject * obj1 = 0 ;
33695 char * kwnames[] = {
33696 (char *) "self",(char *) "win", NULL
33697 };
33698
33699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33701 if (!SWIG_IsOK(res1)) {
33702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33703 }
33704 arg1 = reinterpret_cast< wxWindow * >(argp1);
33705 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33706 if (!SWIG_IsOK(res2)) {
33707 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33708 }
33709 arg2 = reinterpret_cast< wxWindow * >(argp2);
33710 {
33711 PyThreadState* __tstate = wxPyBeginAllowThreads();
33712 (arg1)->MoveBeforeInTabOrder(arg2);
33713 wxPyEndAllowThreads(__tstate);
33714 if (PyErr_Occurred()) SWIG_fail;
33715 }
33716 resultobj = SWIG_Py_Void();
33717 return resultobj;
33718 fail:
33719 return NULL;
33720 }
33721
33722
33723 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33724 PyObject *resultobj = 0;
33725 wxWindow *arg1 = (wxWindow *) 0 ;
33726 PyObject *result = 0 ;
33727 void *argp1 = 0 ;
33728 int res1 = 0 ;
33729 PyObject *swig_obj[1] ;
33730
33731 if (!args) SWIG_fail;
33732 swig_obj[0] = args;
33733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33734 if (!SWIG_IsOK(res1)) {
33735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
33736 }
33737 arg1 = reinterpret_cast< wxWindow * >(argp1);
33738 {
33739 PyThreadState* __tstate = wxPyBeginAllowThreads();
33740 result = (PyObject *)wxWindow_GetChildren(arg1);
33741 wxPyEndAllowThreads(__tstate);
33742 if (PyErr_Occurred()) SWIG_fail;
33743 }
33744 resultobj = result;
33745 return resultobj;
33746 fail:
33747 return NULL;
33748 }
33749
33750
33751 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33752 PyObject *resultobj = 0;
33753 wxWindow *arg1 = (wxWindow *) 0 ;
33754 wxWindow *result = 0 ;
33755 void *argp1 = 0 ;
33756 int res1 = 0 ;
33757 PyObject *swig_obj[1] ;
33758
33759 if (!args) SWIG_fail;
33760 swig_obj[0] = args;
33761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33762 if (!SWIG_IsOK(res1)) {
33763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33764 }
33765 arg1 = reinterpret_cast< wxWindow * >(argp1);
33766 {
33767 PyThreadState* __tstate = wxPyBeginAllowThreads();
33768 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
33769 wxPyEndAllowThreads(__tstate);
33770 if (PyErr_Occurred()) SWIG_fail;
33771 }
33772 {
33773 resultobj = wxPyMake_wxObject(result, 0);
33774 }
33775 return resultobj;
33776 fail:
33777 return NULL;
33778 }
33779
33780
33781 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33782 PyObject *resultobj = 0;
33783 wxWindow *arg1 = (wxWindow *) 0 ;
33784 wxWindow *result = 0 ;
33785 void *argp1 = 0 ;
33786 int res1 = 0 ;
33787 PyObject *swig_obj[1] ;
33788
33789 if (!args) SWIG_fail;
33790 swig_obj[0] = args;
33791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33792 if (!SWIG_IsOK(res1)) {
33793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33794 }
33795 arg1 = reinterpret_cast< wxWindow * >(argp1);
33796 {
33797 PyThreadState* __tstate = wxPyBeginAllowThreads();
33798 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
33799 wxPyEndAllowThreads(__tstate);
33800 if (PyErr_Occurred()) SWIG_fail;
33801 }
33802 {
33803 resultobj = wxPyMake_wxObject(result, 0);
33804 }
33805 return resultobj;
33806 fail:
33807 return NULL;
33808 }
33809
33810
33811 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33812 PyObject *resultobj = 0;
33813 wxWindow *arg1 = (wxWindow *) 0 ;
33814 bool result;
33815 void *argp1 = 0 ;
33816 int res1 = 0 ;
33817 PyObject *swig_obj[1] ;
33818
33819 if (!args) SWIG_fail;
33820 swig_obj[0] = args;
33821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33822 if (!SWIG_IsOK(res1)) {
33823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33824 }
33825 arg1 = reinterpret_cast< wxWindow * >(argp1);
33826 {
33827 PyThreadState* __tstate = wxPyBeginAllowThreads();
33828 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
33829 wxPyEndAllowThreads(__tstate);
33830 if (PyErr_Occurred()) SWIG_fail;
33831 }
33832 {
33833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33834 }
33835 return resultobj;
33836 fail:
33837 return NULL;
33838 }
33839
33840
33841 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33842 PyObject *resultobj = 0;
33843 wxWindow *arg1 = (wxWindow *) 0 ;
33844 wxWindow *arg2 = (wxWindow *) 0 ;
33845 bool result;
33846 void *argp1 = 0 ;
33847 int res1 = 0 ;
33848 void *argp2 = 0 ;
33849 int res2 = 0 ;
33850 PyObject * obj0 = 0 ;
33851 PyObject * obj1 = 0 ;
33852 char * kwnames[] = {
33853 (char *) "self",(char *) "newParent", NULL
33854 };
33855
33856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
33857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33858 if (!SWIG_IsOK(res1)) {
33859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
33860 }
33861 arg1 = reinterpret_cast< wxWindow * >(argp1);
33862 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33863 if (!SWIG_IsOK(res2)) {
33864 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
33865 }
33866 arg2 = reinterpret_cast< wxWindow * >(argp2);
33867 {
33868 PyThreadState* __tstate = wxPyBeginAllowThreads();
33869 result = (bool)(arg1)->Reparent(arg2);
33870 wxPyEndAllowThreads(__tstate);
33871 if (PyErr_Occurred()) SWIG_fail;
33872 }
33873 {
33874 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33875 }
33876 return resultobj;
33877 fail:
33878 return NULL;
33879 }
33880
33881
33882 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33883 PyObject *resultobj = 0;
33884 wxWindow *arg1 = (wxWindow *) 0 ;
33885 wxWindow *arg2 = (wxWindow *) 0 ;
33886 void *argp1 = 0 ;
33887 int res1 = 0 ;
33888 void *argp2 = 0 ;
33889 int res2 = 0 ;
33890 PyObject * obj0 = 0 ;
33891 PyObject * obj1 = 0 ;
33892 char * kwnames[] = {
33893 (char *) "self",(char *) "child", NULL
33894 };
33895
33896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
33897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33898 if (!SWIG_IsOK(res1)) {
33899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33900 }
33901 arg1 = reinterpret_cast< wxWindow * >(argp1);
33902 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33903 if (!SWIG_IsOK(res2)) {
33904 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33905 }
33906 arg2 = reinterpret_cast< wxWindow * >(argp2);
33907 {
33908 PyThreadState* __tstate = wxPyBeginAllowThreads();
33909 (arg1)->AddChild(arg2);
33910 wxPyEndAllowThreads(__tstate);
33911 if (PyErr_Occurred()) SWIG_fail;
33912 }
33913 resultobj = SWIG_Py_Void();
33914 return resultobj;
33915 fail:
33916 return NULL;
33917 }
33918
33919
33920 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33921 PyObject *resultobj = 0;
33922 wxWindow *arg1 = (wxWindow *) 0 ;
33923 wxWindow *arg2 = (wxWindow *) 0 ;
33924 void *argp1 = 0 ;
33925 int res1 = 0 ;
33926 void *argp2 = 0 ;
33927 int res2 = 0 ;
33928 PyObject * obj0 = 0 ;
33929 PyObject * obj1 = 0 ;
33930 char * kwnames[] = {
33931 (char *) "self",(char *) "child", NULL
33932 };
33933
33934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
33935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33936 if (!SWIG_IsOK(res1)) {
33937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33938 }
33939 arg1 = reinterpret_cast< wxWindow * >(argp1);
33940 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33941 if (!SWIG_IsOK(res2)) {
33942 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33943 }
33944 arg2 = reinterpret_cast< wxWindow * >(argp2);
33945 {
33946 PyThreadState* __tstate = wxPyBeginAllowThreads();
33947 (arg1)->RemoveChild(arg2);
33948 wxPyEndAllowThreads(__tstate);
33949 if (PyErr_Occurred()) SWIG_fail;
33950 }
33951 resultobj = SWIG_Py_Void();
33952 return resultobj;
33953 fail:
33954 return NULL;
33955 }
33956
33957
33958 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33959 PyObject *resultobj = 0;
33960 wxWindow *arg1 = (wxWindow *) 0 ;
33961 bool arg2 ;
33962 void *argp1 = 0 ;
33963 int res1 = 0 ;
33964 bool val2 ;
33965 int ecode2 = 0 ;
33966 PyObject * obj0 = 0 ;
33967 PyObject * obj1 = 0 ;
33968 char * kwnames[] = {
33969 (char *) "self",(char *) "on", NULL
33970 };
33971
33972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
33973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33974 if (!SWIG_IsOK(res1)) {
33975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
33976 }
33977 arg1 = reinterpret_cast< wxWindow * >(argp1);
33978 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33979 if (!SWIG_IsOK(ecode2)) {
33980 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
33981 }
33982 arg2 = static_cast< bool >(val2);
33983 {
33984 PyThreadState* __tstate = wxPyBeginAllowThreads();
33985 wxWindow_SetDoubleBuffered(arg1,arg2);
33986 wxPyEndAllowThreads(__tstate);
33987 if (PyErr_Occurred()) SWIG_fail;
33988 }
33989 resultobj = SWIG_Py_Void();
33990 return resultobj;
33991 fail:
33992 return NULL;
33993 }
33994
33995
33996 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33997 PyObject *resultobj = 0;
33998 wxWindow *arg1 = (wxWindow *) 0 ;
33999 long arg2 ;
34000 wxWindow *result = 0 ;
34001 void *argp1 = 0 ;
34002 int res1 = 0 ;
34003 long val2 ;
34004 int ecode2 = 0 ;
34005 PyObject * obj0 = 0 ;
34006 PyObject * obj1 = 0 ;
34007 char * kwnames[] = {
34008 (char *) "self",(char *) "winid", NULL
34009 };
34010
34011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
34012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34013 if (!SWIG_IsOK(res1)) {
34014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
34015 }
34016 arg1 = reinterpret_cast< wxWindow * >(argp1);
34017 ecode2 = SWIG_AsVal_long(obj1, &val2);
34018 if (!SWIG_IsOK(ecode2)) {
34019 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
34020 }
34021 arg2 = static_cast< long >(val2);
34022 {
34023 PyThreadState* __tstate = wxPyBeginAllowThreads();
34024 result = (wxWindow *)(arg1)->FindWindow(arg2);
34025 wxPyEndAllowThreads(__tstate);
34026 if (PyErr_Occurred()) SWIG_fail;
34027 }
34028 {
34029 resultobj = wxPyMake_wxObject(result, 0);
34030 }
34031 return resultobj;
34032 fail:
34033 return NULL;
34034 }
34035
34036
34037 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34038 PyObject *resultobj = 0;
34039 wxWindow *arg1 = (wxWindow *) 0 ;
34040 wxString *arg2 = 0 ;
34041 wxWindow *result = 0 ;
34042 void *argp1 = 0 ;
34043 int res1 = 0 ;
34044 bool temp2 = false ;
34045 PyObject * obj0 = 0 ;
34046 PyObject * obj1 = 0 ;
34047 char * kwnames[] = {
34048 (char *) "self",(char *) "name", NULL
34049 };
34050
34051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
34052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34053 if (!SWIG_IsOK(res1)) {
34054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
34055 }
34056 arg1 = reinterpret_cast< wxWindow * >(argp1);
34057 {
34058 arg2 = wxString_in_helper(obj1);
34059 if (arg2 == NULL) SWIG_fail;
34060 temp2 = true;
34061 }
34062 {
34063 PyThreadState* __tstate = wxPyBeginAllowThreads();
34064 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
34065 wxPyEndAllowThreads(__tstate);
34066 if (PyErr_Occurred()) SWIG_fail;
34067 }
34068 {
34069 resultobj = wxPyMake_wxObject(result, 0);
34070 }
34071 {
34072 if (temp2)
34073 delete arg2;
34074 }
34075 return resultobj;
34076 fail:
34077 {
34078 if (temp2)
34079 delete arg2;
34080 }
34081 return NULL;
34082 }
34083
34084
34085 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34086 PyObject *resultobj = 0;
34087 wxWindow *arg1 = (wxWindow *) 0 ;
34088 wxEvtHandler *result = 0 ;
34089 void *argp1 = 0 ;
34090 int res1 = 0 ;
34091 PyObject *swig_obj[1] ;
34092
34093 if (!args) SWIG_fail;
34094 swig_obj[0] = args;
34095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34096 if (!SWIG_IsOK(res1)) {
34097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
34098 }
34099 arg1 = reinterpret_cast< wxWindow * >(argp1);
34100 {
34101 PyThreadState* __tstate = wxPyBeginAllowThreads();
34102 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
34103 wxPyEndAllowThreads(__tstate);
34104 if (PyErr_Occurred()) SWIG_fail;
34105 }
34106 {
34107 resultobj = wxPyMake_wxObject(result, 0);
34108 }
34109 return resultobj;
34110 fail:
34111 return NULL;
34112 }
34113
34114
34115 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34116 PyObject *resultobj = 0;
34117 wxWindow *arg1 = (wxWindow *) 0 ;
34118 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34119 void *argp1 = 0 ;
34120 int res1 = 0 ;
34121 void *argp2 = 0 ;
34122 int res2 = 0 ;
34123 PyObject * obj0 = 0 ;
34124 PyObject * obj1 = 0 ;
34125 char * kwnames[] = {
34126 (char *) "self",(char *) "handler", NULL
34127 };
34128
34129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34131 if (!SWIG_IsOK(res1)) {
34132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34133 }
34134 arg1 = reinterpret_cast< wxWindow * >(argp1);
34135 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34136 if (!SWIG_IsOK(res2)) {
34137 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34138 }
34139 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34140 {
34141 PyThreadState* __tstate = wxPyBeginAllowThreads();
34142 (arg1)->SetEventHandler(arg2);
34143 wxPyEndAllowThreads(__tstate);
34144 if (PyErr_Occurred()) SWIG_fail;
34145 }
34146 resultobj = SWIG_Py_Void();
34147 return resultobj;
34148 fail:
34149 return NULL;
34150 }
34151
34152
34153 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34154 PyObject *resultobj = 0;
34155 wxWindow *arg1 = (wxWindow *) 0 ;
34156 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34157 void *argp1 = 0 ;
34158 int res1 = 0 ;
34159 void *argp2 = 0 ;
34160 int res2 = 0 ;
34161 PyObject * obj0 = 0 ;
34162 PyObject * obj1 = 0 ;
34163 char * kwnames[] = {
34164 (char *) "self",(char *) "handler", NULL
34165 };
34166
34167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34169 if (!SWIG_IsOK(res1)) {
34170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34171 }
34172 arg1 = reinterpret_cast< wxWindow * >(argp1);
34173 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34174 if (!SWIG_IsOK(res2)) {
34175 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34176 }
34177 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34178 {
34179 PyThreadState* __tstate = wxPyBeginAllowThreads();
34180 (arg1)->PushEventHandler(arg2);
34181 wxPyEndAllowThreads(__tstate);
34182 if (PyErr_Occurred()) SWIG_fail;
34183 }
34184 resultobj = SWIG_Py_Void();
34185 return resultobj;
34186 fail:
34187 return NULL;
34188 }
34189
34190
34191 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34192 PyObject *resultobj = 0;
34193 wxWindow *arg1 = (wxWindow *) 0 ;
34194 bool arg2 = (bool) false ;
34195 wxEvtHandler *result = 0 ;
34196 void *argp1 = 0 ;
34197 int res1 = 0 ;
34198 bool val2 ;
34199 int ecode2 = 0 ;
34200 PyObject * obj0 = 0 ;
34201 PyObject * obj1 = 0 ;
34202 char * kwnames[] = {
34203 (char *) "self",(char *) "deleteHandler", NULL
34204 };
34205
34206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34208 if (!SWIG_IsOK(res1)) {
34209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34210 }
34211 arg1 = reinterpret_cast< wxWindow * >(argp1);
34212 if (obj1) {
34213 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34214 if (!SWIG_IsOK(ecode2)) {
34215 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
34216 }
34217 arg2 = static_cast< bool >(val2);
34218 }
34219 {
34220 PyThreadState* __tstate = wxPyBeginAllowThreads();
34221 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
34222 wxPyEndAllowThreads(__tstate);
34223 if (PyErr_Occurred()) SWIG_fail;
34224 }
34225 {
34226 resultobj = wxPyMake_wxObject(result, 0);
34227 }
34228 return resultobj;
34229 fail:
34230 return NULL;
34231 }
34232
34233
34234 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34235 PyObject *resultobj = 0;
34236 wxWindow *arg1 = (wxWindow *) 0 ;
34237 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34238 bool result;
34239 void *argp1 = 0 ;
34240 int res1 = 0 ;
34241 void *argp2 = 0 ;
34242 int res2 = 0 ;
34243 PyObject * obj0 = 0 ;
34244 PyObject * obj1 = 0 ;
34245 char * kwnames[] = {
34246 (char *) "self",(char *) "handler", NULL
34247 };
34248
34249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34251 if (!SWIG_IsOK(res1)) {
34252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34253 }
34254 arg1 = reinterpret_cast< wxWindow * >(argp1);
34255 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34256 if (!SWIG_IsOK(res2)) {
34257 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34258 }
34259 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34260 {
34261 PyThreadState* __tstate = wxPyBeginAllowThreads();
34262 result = (bool)(arg1)->RemoveEventHandler(arg2);
34263 wxPyEndAllowThreads(__tstate);
34264 if (PyErr_Occurred()) SWIG_fail;
34265 }
34266 {
34267 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34268 }
34269 return resultobj;
34270 fail:
34271 return NULL;
34272 }
34273
34274
34275 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34276 PyObject *resultobj = 0;
34277 wxWindow *arg1 = (wxWindow *) 0 ;
34278 wxValidator *arg2 = 0 ;
34279 void *argp1 = 0 ;
34280 int res1 = 0 ;
34281 void *argp2 = 0 ;
34282 int res2 = 0 ;
34283 PyObject * obj0 = 0 ;
34284 PyObject * obj1 = 0 ;
34285 char * kwnames[] = {
34286 (char *) "self",(char *) "validator", NULL
34287 };
34288
34289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
34290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34291 if (!SWIG_IsOK(res1)) {
34292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
34293 }
34294 arg1 = reinterpret_cast< wxWindow * >(argp1);
34295 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
34296 if (!SWIG_IsOK(res2)) {
34297 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
34298 }
34299 if (!argp2) {
34300 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
34301 }
34302 arg2 = reinterpret_cast< wxValidator * >(argp2);
34303 {
34304 PyThreadState* __tstate = wxPyBeginAllowThreads();
34305 (arg1)->SetValidator((wxValidator const &)*arg2);
34306 wxPyEndAllowThreads(__tstate);
34307 if (PyErr_Occurred()) SWIG_fail;
34308 }
34309 resultobj = SWIG_Py_Void();
34310 return resultobj;
34311 fail:
34312 return NULL;
34313 }
34314
34315
34316 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34317 PyObject *resultobj = 0;
34318 wxWindow *arg1 = (wxWindow *) 0 ;
34319 wxValidator *result = 0 ;
34320 void *argp1 = 0 ;
34321 int res1 = 0 ;
34322 PyObject *swig_obj[1] ;
34323
34324 if (!args) SWIG_fail;
34325 swig_obj[0] = args;
34326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34327 if (!SWIG_IsOK(res1)) {
34328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
34329 }
34330 arg1 = reinterpret_cast< wxWindow * >(argp1);
34331 {
34332 PyThreadState* __tstate = wxPyBeginAllowThreads();
34333 result = (wxValidator *)(arg1)->GetValidator();
34334 wxPyEndAllowThreads(__tstate);
34335 if (PyErr_Occurred()) SWIG_fail;
34336 }
34337 {
34338 resultobj = wxPyMake_wxObject(result, (bool)0);
34339 }
34340 return resultobj;
34341 fail:
34342 return NULL;
34343 }
34344
34345
34346 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34347 PyObject *resultobj = 0;
34348 wxWindow *arg1 = (wxWindow *) 0 ;
34349 bool result;
34350 void *argp1 = 0 ;
34351 int res1 = 0 ;
34352 PyObject *swig_obj[1] ;
34353
34354 if (!args) SWIG_fail;
34355 swig_obj[0] = args;
34356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34357 if (!SWIG_IsOK(res1)) {
34358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
34359 }
34360 arg1 = reinterpret_cast< wxWindow * >(argp1);
34361 {
34362 PyThreadState* __tstate = wxPyBeginAllowThreads();
34363 result = (bool)(arg1)->Validate();
34364 wxPyEndAllowThreads(__tstate);
34365 if (PyErr_Occurred()) SWIG_fail;
34366 }
34367 {
34368 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34369 }
34370 return resultobj;
34371 fail:
34372 return NULL;
34373 }
34374
34375
34376 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34377 PyObject *resultobj = 0;
34378 wxWindow *arg1 = (wxWindow *) 0 ;
34379 bool result;
34380 void *argp1 = 0 ;
34381 int res1 = 0 ;
34382 PyObject *swig_obj[1] ;
34383
34384 if (!args) SWIG_fail;
34385 swig_obj[0] = args;
34386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34387 if (!SWIG_IsOK(res1)) {
34388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
34389 }
34390 arg1 = reinterpret_cast< wxWindow * >(argp1);
34391 {
34392 PyThreadState* __tstate = wxPyBeginAllowThreads();
34393 result = (bool)(arg1)->TransferDataToWindow();
34394 wxPyEndAllowThreads(__tstate);
34395 if (PyErr_Occurred()) SWIG_fail;
34396 }
34397 {
34398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34399 }
34400 return resultobj;
34401 fail:
34402 return NULL;
34403 }
34404
34405
34406 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34407 PyObject *resultobj = 0;
34408 wxWindow *arg1 = (wxWindow *) 0 ;
34409 bool result;
34410 void *argp1 = 0 ;
34411 int res1 = 0 ;
34412 PyObject *swig_obj[1] ;
34413
34414 if (!args) SWIG_fail;
34415 swig_obj[0] = args;
34416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34417 if (!SWIG_IsOK(res1)) {
34418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
34419 }
34420 arg1 = reinterpret_cast< wxWindow * >(argp1);
34421 {
34422 PyThreadState* __tstate = wxPyBeginAllowThreads();
34423 result = (bool)(arg1)->TransferDataFromWindow();
34424 wxPyEndAllowThreads(__tstate);
34425 if (PyErr_Occurred()) SWIG_fail;
34426 }
34427 {
34428 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34429 }
34430 return resultobj;
34431 fail:
34432 return NULL;
34433 }
34434
34435
34436 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34437 PyObject *resultobj = 0;
34438 wxWindow *arg1 = (wxWindow *) 0 ;
34439 void *argp1 = 0 ;
34440 int res1 = 0 ;
34441 PyObject *swig_obj[1] ;
34442
34443 if (!args) SWIG_fail;
34444 swig_obj[0] = args;
34445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34446 if (!SWIG_IsOK(res1)) {
34447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34448 }
34449 arg1 = reinterpret_cast< wxWindow * >(argp1);
34450 {
34451 PyThreadState* __tstate = wxPyBeginAllowThreads();
34452 (arg1)->InitDialog();
34453 wxPyEndAllowThreads(__tstate);
34454 if (PyErr_Occurred()) SWIG_fail;
34455 }
34456 resultobj = SWIG_Py_Void();
34457 return resultobj;
34458 fail:
34459 return NULL;
34460 }
34461
34462
34463 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34464 PyObject *resultobj = 0;
34465 wxWindow *arg1 = (wxWindow *) 0 ;
34466 wxAcceleratorTable *arg2 = 0 ;
34467 void *argp1 = 0 ;
34468 int res1 = 0 ;
34469 void *argp2 = 0 ;
34470 int res2 = 0 ;
34471 PyObject * obj0 = 0 ;
34472 PyObject * obj1 = 0 ;
34473 char * kwnames[] = {
34474 (char *) "self",(char *) "accel", NULL
34475 };
34476
34477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
34478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34479 if (!SWIG_IsOK(res1)) {
34480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
34481 }
34482 arg1 = reinterpret_cast< wxWindow * >(argp1);
34483 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
34484 if (!SWIG_IsOK(res2)) {
34485 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
34486 }
34487 if (!argp2) {
34488 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
34489 }
34490 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
34491 {
34492 PyThreadState* __tstate = wxPyBeginAllowThreads();
34493 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
34494 wxPyEndAllowThreads(__tstate);
34495 if (PyErr_Occurred()) SWIG_fail;
34496 }
34497 resultobj = SWIG_Py_Void();
34498 return resultobj;
34499 fail:
34500 return NULL;
34501 }
34502
34503
34504 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34505 PyObject *resultobj = 0;
34506 wxWindow *arg1 = (wxWindow *) 0 ;
34507 wxAcceleratorTable *result = 0 ;
34508 void *argp1 = 0 ;
34509 int res1 = 0 ;
34510 PyObject *swig_obj[1] ;
34511
34512 if (!args) SWIG_fail;
34513 swig_obj[0] = args;
34514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34515 if (!SWIG_IsOK(res1)) {
34516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
34517 }
34518 arg1 = reinterpret_cast< wxWindow * >(argp1);
34519 {
34520 PyThreadState* __tstate = wxPyBeginAllowThreads();
34521 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
34522 wxPyEndAllowThreads(__tstate);
34523 if (PyErr_Occurred()) SWIG_fail;
34524 }
34525 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
34526 return resultobj;
34527 fail:
34528 return NULL;
34529 }
34530
34531
34532 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34533 PyObject *resultobj = 0;
34534 wxWindow *arg1 = (wxWindow *) 0 ;
34535 int arg2 ;
34536 int arg3 ;
34537 int arg4 ;
34538 bool result;
34539 void *argp1 = 0 ;
34540 int res1 = 0 ;
34541 int val2 ;
34542 int ecode2 = 0 ;
34543 int val3 ;
34544 int ecode3 = 0 ;
34545 int val4 ;
34546 int ecode4 = 0 ;
34547 PyObject * obj0 = 0 ;
34548 PyObject * obj1 = 0 ;
34549 PyObject * obj2 = 0 ;
34550 PyObject * obj3 = 0 ;
34551 char * kwnames[] = {
34552 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
34553 };
34554
34555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34557 if (!SWIG_IsOK(res1)) {
34558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
34559 }
34560 arg1 = reinterpret_cast< wxWindow * >(argp1);
34561 ecode2 = SWIG_AsVal_int(obj1, &val2);
34562 if (!SWIG_IsOK(ecode2)) {
34563 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
34564 }
34565 arg2 = static_cast< int >(val2);
34566 ecode3 = SWIG_AsVal_int(obj2, &val3);
34567 if (!SWIG_IsOK(ecode3)) {
34568 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
34569 }
34570 arg3 = static_cast< int >(val3);
34571 ecode4 = SWIG_AsVal_int(obj3, &val4);
34572 if (!SWIG_IsOK(ecode4)) {
34573 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
34574 }
34575 arg4 = static_cast< int >(val4);
34576 {
34577 PyThreadState* __tstate = wxPyBeginAllowThreads();
34578 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
34579 wxPyEndAllowThreads(__tstate);
34580 if (PyErr_Occurred()) SWIG_fail;
34581 }
34582 {
34583 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34584 }
34585 return resultobj;
34586 fail:
34587 return NULL;
34588 }
34589
34590
34591 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34592 PyObject *resultobj = 0;
34593 wxWindow *arg1 = (wxWindow *) 0 ;
34594 int arg2 ;
34595 bool result;
34596 void *argp1 = 0 ;
34597 int res1 = 0 ;
34598 int val2 ;
34599 int ecode2 = 0 ;
34600 PyObject * obj0 = 0 ;
34601 PyObject * obj1 = 0 ;
34602 char * kwnames[] = {
34603 (char *) "self",(char *) "hotkeyId", NULL
34604 };
34605
34606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
34607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34608 if (!SWIG_IsOK(res1)) {
34609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
34610 }
34611 arg1 = reinterpret_cast< wxWindow * >(argp1);
34612 ecode2 = SWIG_AsVal_int(obj1, &val2);
34613 if (!SWIG_IsOK(ecode2)) {
34614 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
34615 }
34616 arg2 = static_cast< int >(val2);
34617 {
34618 PyThreadState* __tstate = wxPyBeginAllowThreads();
34619 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
34620 wxPyEndAllowThreads(__tstate);
34621 if (PyErr_Occurred()) SWIG_fail;
34622 }
34623 {
34624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34625 }
34626 return resultobj;
34627 fail:
34628 return NULL;
34629 }
34630
34631
34632 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34633 PyObject *resultobj = 0;
34634 wxWindow *arg1 = (wxWindow *) 0 ;
34635 wxPoint *arg2 = 0 ;
34636 wxPoint result;
34637 void *argp1 = 0 ;
34638 int res1 = 0 ;
34639 wxPoint temp2 ;
34640 PyObject * obj0 = 0 ;
34641 PyObject * obj1 = 0 ;
34642 char * kwnames[] = {
34643 (char *) "self",(char *) "pt", NULL
34644 };
34645
34646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
34647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34648 if (!SWIG_IsOK(res1)) {
34649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
34650 }
34651 arg1 = reinterpret_cast< wxWindow * >(argp1);
34652 {
34653 arg2 = &temp2;
34654 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34655 }
34656 {
34657 PyThreadState* __tstate = wxPyBeginAllowThreads();
34658 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34659 wxPyEndAllowThreads(__tstate);
34660 if (PyErr_Occurred()) SWIG_fail;
34661 }
34662 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34663 return resultobj;
34664 fail:
34665 return NULL;
34666 }
34667
34668
34669 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34670 PyObject *resultobj = 0;
34671 wxWindow *arg1 = (wxWindow *) 0 ;
34672 wxSize *arg2 = 0 ;
34673 wxSize result;
34674 void *argp1 = 0 ;
34675 int res1 = 0 ;
34676 wxSize temp2 ;
34677 PyObject * obj0 = 0 ;
34678 PyObject * obj1 = 0 ;
34679 char * kwnames[] = {
34680 (char *) "self",(char *) "sz", NULL
34681 };
34682
34683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
34684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34685 if (!SWIG_IsOK(res1)) {
34686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
34687 }
34688 arg1 = reinterpret_cast< wxWindow * >(argp1);
34689 {
34690 arg2 = &temp2;
34691 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34692 }
34693 {
34694 PyThreadState* __tstate = wxPyBeginAllowThreads();
34695 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34696 wxPyEndAllowThreads(__tstate);
34697 if (PyErr_Occurred()) SWIG_fail;
34698 }
34699 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34700 return resultobj;
34701 fail:
34702 return NULL;
34703 }
34704
34705
34706 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34707 PyObject *resultobj = 0;
34708 wxWindow *arg1 = (wxWindow *) 0 ;
34709 wxPoint *arg2 = 0 ;
34710 wxPoint result;
34711 void *argp1 = 0 ;
34712 int res1 = 0 ;
34713 wxPoint temp2 ;
34714 PyObject * obj0 = 0 ;
34715 PyObject * obj1 = 0 ;
34716 char * kwnames[] = {
34717 (char *) "self",(char *) "pt", NULL
34718 };
34719
34720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
34721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34722 if (!SWIG_IsOK(res1)) {
34723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
34724 }
34725 arg1 = reinterpret_cast< wxWindow * >(argp1);
34726 {
34727 arg2 = &temp2;
34728 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34729 }
34730 {
34731 PyThreadState* __tstate = wxPyBeginAllowThreads();
34732 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34733 wxPyEndAllowThreads(__tstate);
34734 if (PyErr_Occurred()) SWIG_fail;
34735 }
34736 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34737 return resultobj;
34738 fail:
34739 return NULL;
34740 }
34741
34742
34743 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34744 PyObject *resultobj = 0;
34745 wxWindow *arg1 = (wxWindow *) 0 ;
34746 wxSize *arg2 = 0 ;
34747 wxSize result;
34748 void *argp1 = 0 ;
34749 int res1 = 0 ;
34750 wxSize temp2 ;
34751 PyObject * obj0 = 0 ;
34752 PyObject * obj1 = 0 ;
34753 char * kwnames[] = {
34754 (char *) "self",(char *) "sz", NULL
34755 };
34756
34757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
34758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34759 if (!SWIG_IsOK(res1)) {
34760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
34761 }
34762 arg1 = reinterpret_cast< wxWindow * >(argp1);
34763 {
34764 arg2 = &temp2;
34765 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34766 }
34767 {
34768 PyThreadState* __tstate = wxPyBeginAllowThreads();
34769 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34770 wxPyEndAllowThreads(__tstate);
34771 if (PyErr_Occurred()) SWIG_fail;
34772 }
34773 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34774 return resultobj;
34775 fail:
34776 return NULL;
34777 }
34778
34779
34780 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34781 PyObject *resultobj = 0;
34782 wxWindow *arg1 = (wxWindow *) 0 ;
34783 wxPoint *arg2 = 0 ;
34784 wxPoint result;
34785 void *argp1 = 0 ;
34786 int res1 = 0 ;
34787 wxPoint temp2 ;
34788 PyObject * obj0 = 0 ;
34789 PyObject * obj1 = 0 ;
34790 char * kwnames[] = {
34791 (char *) "self",(char *) "pt", NULL
34792 };
34793
34794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34796 if (!SWIG_IsOK(res1)) {
34797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34798 }
34799 arg1 = reinterpret_cast< wxWindow * >(argp1);
34800 {
34801 arg2 = &temp2;
34802 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34803 }
34804 {
34805 PyThreadState* __tstate = wxPyBeginAllowThreads();
34806 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
34807 wxPyEndAllowThreads(__tstate);
34808 if (PyErr_Occurred()) SWIG_fail;
34809 }
34810 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34811 return resultobj;
34812 fail:
34813 return NULL;
34814 }
34815
34816
34817 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34818 PyObject *resultobj = 0;
34819 wxWindow *arg1 = (wxWindow *) 0 ;
34820 wxSize *arg2 = 0 ;
34821 wxSize result;
34822 void *argp1 = 0 ;
34823 int res1 = 0 ;
34824 wxSize temp2 ;
34825 PyObject * obj0 = 0 ;
34826 PyObject * obj1 = 0 ;
34827 char * kwnames[] = {
34828 (char *) "self",(char *) "sz", NULL
34829 };
34830
34831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34833 if (!SWIG_IsOK(res1)) {
34834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34835 }
34836 arg1 = reinterpret_cast< wxWindow * >(argp1);
34837 {
34838 arg2 = &temp2;
34839 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34840 }
34841 {
34842 PyThreadState* __tstate = wxPyBeginAllowThreads();
34843 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
34844 wxPyEndAllowThreads(__tstate);
34845 if (PyErr_Occurred()) SWIG_fail;
34846 }
34847 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34848 return resultobj;
34849 fail:
34850 return NULL;
34851 }
34852
34853
34854 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34855 PyObject *resultobj = 0;
34856 wxWindow *arg1 = (wxWindow *) 0 ;
34857 int arg2 ;
34858 int arg3 ;
34859 void *argp1 = 0 ;
34860 int res1 = 0 ;
34861 int val2 ;
34862 int ecode2 = 0 ;
34863 int val3 ;
34864 int ecode3 = 0 ;
34865 PyObject * obj0 = 0 ;
34866 PyObject * obj1 = 0 ;
34867 PyObject * obj2 = 0 ;
34868 char * kwnames[] = {
34869 (char *) "self",(char *) "x",(char *) "y", NULL
34870 };
34871
34872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34874 if (!SWIG_IsOK(res1)) {
34875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
34876 }
34877 arg1 = reinterpret_cast< wxWindow * >(argp1);
34878 ecode2 = SWIG_AsVal_int(obj1, &val2);
34879 if (!SWIG_IsOK(ecode2)) {
34880 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
34881 }
34882 arg2 = static_cast< int >(val2);
34883 ecode3 = SWIG_AsVal_int(obj2, &val3);
34884 if (!SWIG_IsOK(ecode3)) {
34885 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
34886 }
34887 arg3 = static_cast< int >(val3);
34888 {
34889 PyThreadState* __tstate = wxPyBeginAllowThreads();
34890 (arg1)->WarpPointer(arg2,arg3);
34891 wxPyEndAllowThreads(__tstate);
34892 if (PyErr_Occurred()) SWIG_fail;
34893 }
34894 resultobj = SWIG_Py_Void();
34895 return resultobj;
34896 fail:
34897 return NULL;
34898 }
34899
34900
34901 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34902 PyObject *resultobj = 0;
34903 wxWindow *arg1 = (wxWindow *) 0 ;
34904 void *argp1 = 0 ;
34905 int res1 = 0 ;
34906 PyObject *swig_obj[1] ;
34907
34908 if (!args) SWIG_fail;
34909 swig_obj[0] = args;
34910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34911 if (!SWIG_IsOK(res1)) {
34912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34913 }
34914 arg1 = reinterpret_cast< wxWindow * >(argp1);
34915 {
34916 PyThreadState* __tstate = wxPyBeginAllowThreads();
34917 (arg1)->CaptureMouse();
34918 wxPyEndAllowThreads(__tstate);
34919 if (PyErr_Occurred()) SWIG_fail;
34920 }
34921 resultobj = SWIG_Py_Void();
34922 return resultobj;
34923 fail:
34924 return NULL;
34925 }
34926
34927
34928 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34929 PyObject *resultobj = 0;
34930 wxWindow *arg1 = (wxWindow *) 0 ;
34931 void *argp1 = 0 ;
34932 int res1 = 0 ;
34933 PyObject *swig_obj[1] ;
34934
34935 if (!args) SWIG_fail;
34936 swig_obj[0] = args;
34937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34938 if (!SWIG_IsOK(res1)) {
34939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34940 }
34941 arg1 = reinterpret_cast< wxWindow * >(argp1);
34942 {
34943 PyThreadState* __tstate = wxPyBeginAllowThreads();
34944 (arg1)->ReleaseMouse();
34945 wxPyEndAllowThreads(__tstate);
34946 if (PyErr_Occurred()) SWIG_fail;
34947 }
34948 resultobj = SWIG_Py_Void();
34949 return resultobj;
34950 fail:
34951 return NULL;
34952 }
34953
34954
34955 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34956 PyObject *resultobj = 0;
34957 wxWindow *result = 0 ;
34958
34959 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
34960 {
34961 if (!wxPyCheckForApp()) SWIG_fail;
34962 PyThreadState* __tstate = wxPyBeginAllowThreads();
34963 result = (wxWindow *)wxWindow::GetCapture();
34964 wxPyEndAllowThreads(__tstate);
34965 if (PyErr_Occurred()) SWIG_fail;
34966 }
34967 {
34968 resultobj = wxPyMake_wxObject(result, 0);
34969 }
34970 return resultobj;
34971 fail:
34972 return NULL;
34973 }
34974
34975
34976 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34977 PyObject *resultobj = 0;
34978 wxWindow *arg1 = (wxWindow *) 0 ;
34979 bool result;
34980 void *argp1 = 0 ;
34981 int res1 = 0 ;
34982 PyObject *swig_obj[1] ;
34983
34984 if (!args) SWIG_fail;
34985 swig_obj[0] = args;
34986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34987 if (!SWIG_IsOK(res1)) {
34988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
34989 }
34990 arg1 = reinterpret_cast< wxWindow * >(argp1);
34991 {
34992 PyThreadState* __tstate = wxPyBeginAllowThreads();
34993 result = (bool)((wxWindow const *)arg1)->HasCapture();
34994 wxPyEndAllowThreads(__tstate);
34995 if (PyErr_Occurred()) SWIG_fail;
34996 }
34997 {
34998 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34999 }
35000 return resultobj;
35001 fail:
35002 return NULL;
35003 }
35004
35005
35006 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35007 PyObject *resultobj = 0;
35008 wxWindow *arg1 = (wxWindow *) 0 ;
35009 bool arg2 = (bool) true ;
35010 wxRect *arg3 = (wxRect *) NULL ;
35011 void *argp1 = 0 ;
35012 int res1 = 0 ;
35013 bool val2 ;
35014 int ecode2 = 0 ;
35015 void *argp3 = 0 ;
35016 int res3 = 0 ;
35017 PyObject * obj0 = 0 ;
35018 PyObject * obj1 = 0 ;
35019 PyObject * obj2 = 0 ;
35020 char * kwnames[] = {
35021 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
35022 };
35023
35024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35026 if (!SWIG_IsOK(res1)) {
35027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
35028 }
35029 arg1 = reinterpret_cast< wxWindow * >(argp1);
35030 if (obj1) {
35031 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35032 if (!SWIG_IsOK(ecode2)) {
35033 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
35034 }
35035 arg2 = static_cast< bool >(val2);
35036 }
35037 if (obj2) {
35038 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
35039 if (!SWIG_IsOK(res3)) {
35040 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
35041 }
35042 arg3 = reinterpret_cast< wxRect * >(argp3);
35043 }
35044 {
35045 PyThreadState* __tstate = wxPyBeginAllowThreads();
35046 (arg1)->Refresh(arg2,(wxRect const *)arg3);
35047 wxPyEndAllowThreads(__tstate);
35048 if (PyErr_Occurred()) SWIG_fail;
35049 }
35050 resultobj = SWIG_Py_Void();
35051 return resultobj;
35052 fail:
35053 return NULL;
35054 }
35055
35056
35057 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35058 PyObject *resultobj = 0;
35059 wxWindow *arg1 = (wxWindow *) 0 ;
35060 wxRect *arg2 = 0 ;
35061 bool arg3 = (bool) true ;
35062 void *argp1 = 0 ;
35063 int res1 = 0 ;
35064 wxRect temp2 ;
35065 bool val3 ;
35066 int ecode3 = 0 ;
35067 PyObject * obj0 = 0 ;
35068 PyObject * obj1 = 0 ;
35069 PyObject * obj2 = 0 ;
35070 char * kwnames[] = {
35071 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
35072 };
35073
35074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35076 if (!SWIG_IsOK(res1)) {
35077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
35078 }
35079 arg1 = reinterpret_cast< wxWindow * >(argp1);
35080 {
35081 arg2 = &temp2;
35082 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
35083 }
35084 if (obj2) {
35085 ecode3 = SWIG_AsVal_bool(obj2, &val3);
35086 if (!SWIG_IsOK(ecode3)) {
35087 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
35088 }
35089 arg3 = static_cast< bool >(val3);
35090 }
35091 {
35092 PyThreadState* __tstate = wxPyBeginAllowThreads();
35093 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
35094 wxPyEndAllowThreads(__tstate);
35095 if (PyErr_Occurred()) SWIG_fail;
35096 }
35097 resultobj = SWIG_Py_Void();
35098 return resultobj;
35099 fail:
35100 return NULL;
35101 }
35102
35103
35104 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35105 PyObject *resultobj = 0;
35106 wxWindow *arg1 = (wxWindow *) 0 ;
35107 void *argp1 = 0 ;
35108 int res1 = 0 ;
35109 PyObject *swig_obj[1] ;
35110
35111 if (!args) SWIG_fail;
35112 swig_obj[0] = args;
35113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35114 if (!SWIG_IsOK(res1)) {
35115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
35116 }
35117 arg1 = reinterpret_cast< wxWindow * >(argp1);
35118 {
35119 PyThreadState* __tstate = wxPyBeginAllowThreads();
35120 (arg1)->Update();
35121 wxPyEndAllowThreads(__tstate);
35122 if (PyErr_Occurred()) SWIG_fail;
35123 }
35124 resultobj = SWIG_Py_Void();
35125 return resultobj;
35126 fail:
35127 return NULL;
35128 }
35129
35130
35131 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35132 PyObject *resultobj = 0;
35133 wxWindow *arg1 = (wxWindow *) 0 ;
35134 void *argp1 = 0 ;
35135 int res1 = 0 ;
35136 PyObject *swig_obj[1] ;
35137
35138 if (!args) SWIG_fail;
35139 swig_obj[0] = args;
35140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35141 if (!SWIG_IsOK(res1)) {
35142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35143 }
35144 arg1 = reinterpret_cast< wxWindow * >(argp1);
35145 {
35146 PyThreadState* __tstate = wxPyBeginAllowThreads();
35147 (arg1)->ClearBackground();
35148 wxPyEndAllowThreads(__tstate);
35149 if (PyErr_Occurred()) SWIG_fail;
35150 }
35151 resultobj = SWIG_Py_Void();
35152 return resultobj;
35153 fail:
35154 return NULL;
35155 }
35156
35157
35158 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35159 PyObject *resultobj = 0;
35160 wxWindow *arg1 = (wxWindow *) 0 ;
35161 void *argp1 = 0 ;
35162 int res1 = 0 ;
35163 PyObject *swig_obj[1] ;
35164
35165 if (!args) SWIG_fail;
35166 swig_obj[0] = args;
35167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35168 if (!SWIG_IsOK(res1)) {
35169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
35170 }
35171 arg1 = reinterpret_cast< wxWindow * >(argp1);
35172 {
35173 PyThreadState* __tstate = wxPyBeginAllowThreads();
35174 (arg1)->Freeze();
35175 wxPyEndAllowThreads(__tstate);
35176 if (PyErr_Occurred()) SWIG_fail;
35177 }
35178 resultobj = SWIG_Py_Void();
35179 return resultobj;
35180 fail:
35181 return NULL;
35182 }
35183
35184
35185 SWIGINTERN PyObject *_wrap_Window_IsFrozen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35186 PyObject *resultobj = 0;
35187 wxWindow *arg1 = (wxWindow *) 0 ;
35188 bool result;
35189 void *argp1 = 0 ;
35190 int res1 = 0 ;
35191 PyObject *swig_obj[1] ;
35192
35193 if (!args) SWIG_fail;
35194 swig_obj[0] = args;
35195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35196 if (!SWIG_IsOK(res1)) {
35197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsFrozen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35198 }
35199 arg1 = reinterpret_cast< wxWindow * >(argp1);
35200 {
35201 PyThreadState* __tstate = wxPyBeginAllowThreads();
35202 result = (bool)((wxWindow const *)arg1)->IsFrozen();
35203 wxPyEndAllowThreads(__tstate);
35204 if (PyErr_Occurred()) SWIG_fail;
35205 }
35206 {
35207 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35208 }
35209 return resultobj;
35210 fail:
35211 return NULL;
35212 }
35213
35214
35215 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35216 PyObject *resultobj = 0;
35217 wxWindow *arg1 = (wxWindow *) 0 ;
35218 void *argp1 = 0 ;
35219 int res1 = 0 ;
35220 PyObject *swig_obj[1] ;
35221
35222 if (!args) SWIG_fail;
35223 swig_obj[0] = args;
35224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35225 if (!SWIG_IsOK(res1)) {
35226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
35227 }
35228 arg1 = reinterpret_cast< wxWindow * >(argp1);
35229 {
35230 PyThreadState* __tstate = wxPyBeginAllowThreads();
35231 (arg1)->Thaw();
35232 wxPyEndAllowThreads(__tstate);
35233 if (PyErr_Occurred()) SWIG_fail;
35234 }
35235 resultobj = SWIG_Py_Void();
35236 return resultobj;
35237 fail:
35238 return NULL;
35239 }
35240
35241
35242 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35243 PyObject *resultobj = 0;
35244 wxWindow *arg1 = (wxWindow *) 0 ;
35245 wxDC *arg2 = 0 ;
35246 void *argp1 = 0 ;
35247 int res1 = 0 ;
35248 void *argp2 = 0 ;
35249 int res2 = 0 ;
35250 PyObject * obj0 = 0 ;
35251 PyObject * obj1 = 0 ;
35252 char * kwnames[] = {
35253 (char *) "self",(char *) "dc", NULL
35254 };
35255
35256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
35257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35258 if (!SWIG_IsOK(res1)) {
35259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
35260 }
35261 arg1 = reinterpret_cast< wxWindow * >(argp1);
35262 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
35263 if (!SWIG_IsOK(res2)) {
35264 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
35265 }
35266 if (!argp2) {
35267 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
35268 }
35269 arg2 = reinterpret_cast< wxDC * >(argp2);
35270 {
35271 PyThreadState* __tstate = wxPyBeginAllowThreads();
35272 (arg1)->PrepareDC(*arg2);
35273 wxPyEndAllowThreads(__tstate);
35274 if (PyErr_Occurred()) SWIG_fail;
35275 }
35276 resultobj = SWIG_Py_Void();
35277 return resultobj;
35278 fail:
35279 return NULL;
35280 }
35281
35282
35283 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35284 PyObject *resultobj = 0;
35285 wxWindow *arg1 = (wxWindow *) 0 ;
35286 wxRegion *result = 0 ;
35287 void *argp1 = 0 ;
35288 int res1 = 0 ;
35289 PyObject *swig_obj[1] ;
35290
35291 if (!args) SWIG_fail;
35292 swig_obj[0] = args;
35293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35294 if (!SWIG_IsOK(res1)) {
35295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
35296 }
35297 arg1 = reinterpret_cast< wxWindow * >(argp1);
35298 {
35299 PyThreadState* __tstate = wxPyBeginAllowThreads();
35300 {
35301 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
35302 result = (wxRegion *) &_result_ref;
35303 }
35304 wxPyEndAllowThreads(__tstate);
35305 if (PyErr_Occurred()) SWIG_fail;
35306 }
35307 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
35308 return resultobj;
35309 fail:
35310 return NULL;
35311 }
35312
35313
35314 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35315 PyObject *resultobj = 0;
35316 wxWindow *arg1 = (wxWindow *) 0 ;
35317 wxRect result;
35318 void *argp1 = 0 ;
35319 int res1 = 0 ;
35320 PyObject *swig_obj[1] ;
35321
35322 if (!args) SWIG_fail;
35323 swig_obj[0] = args;
35324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35325 if (!SWIG_IsOK(res1)) {
35326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
35327 }
35328 arg1 = reinterpret_cast< wxWindow * >(argp1);
35329 {
35330 PyThreadState* __tstate = wxPyBeginAllowThreads();
35331 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
35332 wxPyEndAllowThreads(__tstate);
35333 if (PyErr_Occurred()) SWIG_fail;
35334 }
35335 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35336 return resultobj;
35337 fail:
35338 return NULL;
35339 }
35340
35341
35342 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35343 PyObject *resultobj = 0;
35344 wxWindow *arg1 = (wxWindow *) 0 ;
35345 int arg2 ;
35346 int arg3 ;
35347 int arg4 = (int) 1 ;
35348 int arg5 = (int) 1 ;
35349 bool result;
35350 void *argp1 = 0 ;
35351 int res1 = 0 ;
35352 int val2 ;
35353 int ecode2 = 0 ;
35354 int val3 ;
35355 int ecode3 = 0 ;
35356 int val4 ;
35357 int ecode4 = 0 ;
35358 int val5 ;
35359 int ecode5 = 0 ;
35360 PyObject * obj0 = 0 ;
35361 PyObject * obj1 = 0 ;
35362 PyObject * obj2 = 0 ;
35363 PyObject * obj3 = 0 ;
35364 PyObject * obj4 = 0 ;
35365 char * kwnames[] = {
35366 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
35367 };
35368
35369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
35370 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35371 if (!SWIG_IsOK(res1)) {
35372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
35373 }
35374 arg1 = reinterpret_cast< wxWindow * >(argp1);
35375 ecode2 = SWIG_AsVal_int(obj1, &val2);
35376 if (!SWIG_IsOK(ecode2)) {
35377 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
35378 }
35379 arg2 = static_cast< int >(val2);
35380 ecode3 = SWIG_AsVal_int(obj2, &val3);
35381 if (!SWIG_IsOK(ecode3)) {
35382 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
35383 }
35384 arg3 = static_cast< int >(val3);
35385 if (obj3) {
35386 ecode4 = SWIG_AsVal_int(obj3, &val4);
35387 if (!SWIG_IsOK(ecode4)) {
35388 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
35389 }
35390 arg4 = static_cast< int >(val4);
35391 }
35392 if (obj4) {
35393 ecode5 = SWIG_AsVal_int(obj4, &val5);
35394 if (!SWIG_IsOK(ecode5)) {
35395 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
35396 }
35397 arg5 = static_cast< int >(val5);
35398 }
35399 {
35400 PyThreadState* __tstate = wxPyBeginAllowThreads();
35401 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
35402 wxPyEndAllowThreads(__tstate);
35403 if (PyErr_Occurred()) SWIG_fail;
35404 }
35405 {
35406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35407 }
35408 return resultobj;
35409 fail:
35410 return NULL;
35411 }
35412
35413
35414 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35415 PyObject *resultobj = 0;
35416 wxWindow *arg1 = (wxWindow *) 0 ;
35417 wxPoint *arg2 = 0 ;
35418 bool result;
35419 void *argp1 = 0 ;
35420 int res1 = 0 ;
35421 wxPoint temp2 ;
35422 PyObject * obj0 = 0 ;
35423 PyObject * obj1 = 0 ;
35424 char * kwnames[] = {
35425 (char *) "self",(char *) "pt", NULL
35426 };
35427
35428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
35429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35430 if (!SWIG_IsOK(res1)) {
35431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
35432 }
35433 arg1 = reinterpret_cast< wxWindow * >(argp1);
35434 {
35435 arg2 = &temp2;
35436 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35437 }
35438 {
35439 PyThreadState* __tstate = wxPyBeginAllowThreads();
35440 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
35441 wxPyEndAllowThreads(__tstate);
35442 if (PyErr_Occurred()) SWIG_fail;
35443 }
35444 {
35445 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35446 }
35447 return resultobj;
35448 fail:
35449 return NULL;
35450 }
35451
35452
35453 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35454 PyObject *resultobj = 0;
35455 wxWindow *arg1 = (wxWindow *) 0 ;
35456 wxRect *arg2 = 0 ;
35457 bool result;
35458 void *argp1 = 0 ;
35459 int res1 = 0 ;
35460 wxRect temp2 ;
35461 PyObject * obj0 = 0 ;
35462 PyObject * obj1 = 0 ;
35463 char * kwnames[] = {
35464 (char *) "self",(char *) "rect", NULL
35465 };
35466
35467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
35468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35469 if (!SWIG_IsOK(res1)) {
35470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
35471 }
35472 arg1 = reinterpret_cast< wxWindow * >(argp1);
35473 {
35474 arg2 = &temp2;
35475 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
35476 }
35477 {
35478 PyThreadState* __tstate = wxPyBeginAllowThreads();
35479 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
35480 wxPyEndAllowThreads(__tstate);
35481 if (PyErr_Occurred()) SWIG_fail;
35482 }
35483 {
35484 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35485 }
35486 return resultobj;
35487 fail:
35488 return NULL;
35489 }
35490
35491
35492 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35493 PyObject *resultobj = 0;
35494 wxWindow *arg1 = (wxWindow *) 0 ;
35495 SwigValueWrapper<wxVisualAttributes > result;
35496 void *argp1 = 0 ;
35497 int res1 = 0 ;
35498 PyObject *swig_obj[1] ;
35499
35500 if (!args) SWIG_fail;
35501 swig_obj[0] = args;
35502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35503 if (!SWIG_IsOK(res1)) {
35504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
35505 }
35506 arg1 = reinterpret_cast< wxWindow * >(argp1);
35507 {
35508 PyThreadState* __tstate = wxPyBeginAllowThreads();
35509 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
35510 wxPyEndAllowThreads(__tstate);
35511 if (PyErr_Occurred()) SWIG_fail;
35512 }
35513 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
35514 return resultobj;
35515 fail:
35516 return NULL;
35517 }
35518
35519
35520 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35521 PyObject *resultobj = 0;
35522 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
35523 SwigValueWrapper<wxVisualAttributes > result;
35524 int val1 ;
35525 int ecode1 = 0 ;
35526 PyObject * obj0 = 0 ;
35527 char * kwnames[] = {
35528 (char *) "variant", NULL
35529 };
35530
35531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
35532 if (obj0) {
35533 ecode1 = SWIG_AsVal_int(obj0, &val1);
35534 if (!SWIG_IsOK(ecode1)) {
35535 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
35536 }
35537 arg1 = static_cast< wxWindowVariant >(val1);
35538 }
35539 {
35540 if (!wxPyCheckForApp()) SWIG_fail;
35541 PyThreadState* __tstate = wxPyBeginAllowThreads();
35542 result = wxWindow::GetClassDefaultAttributes(arg1);
35543 wxPyEndAllowThreads(__tstate);
35544 if (PyErr_Occurred()) SWIG_fail;
35545 }
35546 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
35547 return resultobj;
35548 fail:
35549 return NULL;
35550 }
35551
35552
35553 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35554 PyObject *resultobj = 0;
35555 wxWindow *arg1 = (wxWindow *) 0 ;
35556 wxColour *arg2 = 0 ;
35557 bool result;
35558 void *argp1 = 0 ;
35559 int res1 = 0 ;
35560 wxColour temp2 ;
35561 PyObject * obj0 = 0 ;
35562 PyObject * obj1 = 0 ;
35563 char * kwnames[] = {
35564 (char *) "self",(char *) "colour", NULL
35565 };
35566
35567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35569 if (!SWIG_IsOK(res1)) {
35570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35571 }
35572 arg1 = reinterpret_cast< wxWindow * >(argp1);
35573 {
35574 arg2 = &temp2;
35575 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35576 }
35577 {
35578 PyThreadState* __tstate = wxPyBeginAllowThreads();
35579 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
35580 wxPyEndAllowThreads(__tstate);
35581 if (PyErr_Occurred()) SWIG_fail;
35582 }
35583 {
35584 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35585 }
35586 return resultobj;
35587 fail:
35588 return NULL;
35589 }
35590
35591
35592 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35593 PyObject *resultobj = 0;
35594 wxWindow *arg1 = (wxWindow *) 0 ;
35595 wxColour *arg2 = 0 ;
35596 void *argp1 = 0 ;
35597 int res1 = 0 ;
35598 wxColour temp2 ;
35599 PyObject * obj0 = 0 ;
35600 PyObject * obj1 = 0 ;
35601 char * kwnames[] = {
35602 (char *) "self",(char *) "colour", NULL
35603 };
35604
35605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35607 if (!SWIG_IsOK(res1)) {
35608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35609 }
35610 arg1 = reinterpret_cast< wxWindow * >(argp1);
35611 {
35612 arg2 = &temp2;
35613 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35614 }
35615 {
35616 PyThreadState* __tstate = wxPyBeginAllowThreads();
35617 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
35618 wxPyEndAllowThreads(__tstate);
35619 if (PyErr_Occurred()) SWIG_fail;
35620 }
35621 resultobj = SWIG_Py_Void();
35622 return resultobj;
35623 fail:
35624 return NULL;
35625 }
35626
35627
35628 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35629 PyObject *resultobj = 0;
35630 wxWindow *arg1 = (wxWindow *) 0 ;
35631 wxColour *arg2 = 0 ;
35632 bool result;
35633 void *argp1 = 0 ;
35634 int res1 = 0 ;
35635 wxColour temp2 ;
35636 PyObject * obj0 = 0 ;
35637 PyObject * obj1 = 0 ;
35638 char * kwnames[] = {
35639 (char *) "self",(char *) "colour", NULL
35640 };
35641
35642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35644 if (!SWIG_IsOK(res1)) {
35645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35646 }
35647 arg1 = reinterpret_cast< wxWindow * >(argp1);
35648 {
35649 arg2 = &temp2;
35650 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35651 }
35652 {
35653 PyThreadState* __tstate = wxPyBeginAllowThreads();
35654 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
35655 wxPyEndAllowThreads(__tstate);
35656 if (PyErr_Occurred()) SWIG_fail;
35657 }
35658 {
35659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35660 }
35661 return resultobj;
35662 fail:
35663 return NULL;
35664 }
35665
35666
35667 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35668 PyObject *resultobj = 0;
35669 wxWindow *arg1 = (wxWindow *) 0 ;
35670 wxColour *arg2 = 0 ;
35671 void *argp1 = 0 ;
35672 int res1 = 0 ;
35673 wxColour temp2 ;
35674 PyObject * obj0 = 0 ;
35675 PyObject * obj1 = 0 ;
35676 char * kwnames[] = {
35677 (char *) "self",(char *) "colour", NULL
35678 };
35679
35680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35682 if (!SWIG_IsOK(res1)) {
35683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35684 }
35685 arg1 = reinterpret_cast< wxWindow * >(argp1);
35686 {
35687 arg2 = &temp2;
35688 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35689 }
35690 {
35691 PyThreadState* __tstate = wxPyBeginAllowThreads();
35692 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
35693 wxPyEndAllowThreads(__tstate);
35694 if (PyErr_Occurred()) SWIG_fail;
35695 }
35696 resultobj = SWIG_Py_Void();
35697 return resultobj;
35698 fail:
35699 return NULL;
35700 }
35701
35702
35703 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35704 PyObject *resultobj = 0;
35705 wxWindow *arg1 = (wxWindow *) 0 ;
35706 wxColour result;
35707 void *argp1 = 0 ;
35708 int res1 = 0 ;
35709 PyObject *swig_obj[1] ;
35710
35711 if (!args) SWIG_fail;
35712 swig_obj[0] = args;
35713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35714 if (!SWIG_IsOK(res1)) {
35715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35716 }
35717 arg1 = reinterpret_cast< wxWindow * >(argp1);
35718 {
35719 PyThreadState* __tstate = wxPyBeginAllowThreads();
35720 result = ((wxWindow const *)arg1)->GetBackgroundColour();
35721 wxPyEndAllowThreads(__tstate);
35722 if (PyErr_Occurred()) SWIG_fail;
35723 }
35724 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35725 return resultobj;
35726 fail:
35727 return NULL;
35728 }
35729
35730
35731 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35732 PyObject *resultobj = 0;
35733 wxWindow *arg1 = (wxWindow *) 0 ;
35734 wxColour result;
35735 void *argp1 = 0 ;
35736 int res1 = 0 ;
35737 PyObject *swig_obj[1] ;
35738
35739 if (!args) SWIG_fail;
35740 swig_obj[0] = args;
35741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35742 if (!SWIG_IsOK(res1)) {
35743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35744 }
35745 arg1 = reinterpret_cast< wxWindow * >(argp1);
35746 {
35747 PyThreadState* __tstate = wxPyBeginAllowThreads();
35748 result = ((wxWindow const *)arg1)->GetForegroundColour();
35749 wxPyEndAllowThreads(__tstate);
35750 if (PyErr_Occurred()) SWIG_fail;
35751 }
35752 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35753 return resultobj;
35754 fail:
35755 return NULL;
35756 }
35757
35758
35759 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35760 PyObject *resultobj = 0;
35761 wxWindow *arg1 = (wxWindow *) 0 ;
35762 bool result;
35763 void *argp1 = 0 ;
35764 int res1 = 0 ;
35765 PyObject *swig_obj[1] ;
35766
35767 if (!args) SWIG_fail;
35768 swig_obj[0] = args;
35769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35770 if (!SWIG_IsOK(res1)) {
35771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35772 }
35773 arg1 = reinterpret_cast< wxWindow * >(argp1);
35774 {
35775 PyThreadState* __tstate = wxPyBeginAllowThreads();
35776 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
35777 wxPyEndAllowThreads(__tstate);
35778 if (PyErr_Occurred()) SWIG_fail;
35779 }
35780 {
35781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35782 }
35783 return resultobj;
35784 fail:
35785 return NULL;
35786 }
35787
35788
35789 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35790 PyObject *resultobj = 0;
35791 wxWindow *arg1 = (wxWindow *) 0 ;
35792 bool result;
35793 void *argp1 = 0 ;
35794 int res1 = 0 ;
35795 PyObject *swig_obj[1] ;
35796
35797 if (!args) SWIG_fail;
35798 swig_obj[0] = args;
35799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35800 if (!SWIG_IsOK(res1)) {
35801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
35802 }
35803 arg1 = reinterpret_cast< wxWindow * >(argp1);
35804 {
35805 PyThreadState* __tstate = wxPyBeginAllowThreads();
35806 result = (bool)((wxWindow const *)arg1)->UseBgCol();
35807 wxPyEndAllowThreads(__tstate);
35808 if (PyErr_Occurred()) SWIG_fail;
35809 }
35810 {
35811 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35812 }
35813 return resultobj;
35814 fail:
35815 return NULL;
35816 }
35817
35818
35819 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35820 PyObject *resultobj = 0;
35821 wxWindow *arg1 = (wxWindow *) 0 ;
35822 wxBackgroundStyle arg2 ;
35823 bool result;
35824 void *argp1 = 0 ;
35825 int res1 = 0 ;
35826 int val2 ;
35827 int ecode2 = 0 ;
35828 PyObject * obj0 = 0 ;
35829 PyObject * obj1 = 0 ;
35830 char * kwnames[] = {
35831 (char *) "self",(char *) "style", NULL
35832 };
35833
35834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35836 if (!SWIG_IsOK(res1)) {
35837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35838 }
35839 arg1 = reinterpret_cast< wxWindow * >(argp1);
35840 ecode2 = SWIG_AsVal_int(obj1, &val2);
35841 if (!SWIG_IsOK(ecode2)) {
35842 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
35843 }
35844 arg2 = static_cast< wxBackgroundStyle >(val2);
35845 {
35846 PyThreadState* __tstate = wxPyBeginAllowThreads();
35847 result = (bool)(arg1)->SetBackgroundStyle(arg2);
35848 wxPyEndAllowThreads(__tstate);
35849 if (PyErr_Occurred()) SWIG_fail;
35850 }
35851 {
35852 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35853 }
35854 return resultobj;
35855 fail:
35856 return NULL;
35857 }
35858
35859
35860 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35861 PyObject *resultobj = 0;
35862 wxWindow *arg1 = (wxWindow *) 0 ;
35863 wxBackgroundStyle result;
35864 void *argp1 = 0 ;
35865 int res1 = 0 ;
35866 PyObject *swig_obj[1] ;
35867
35868 if (!args) SWIG_fail;
35869 swig_obj[0] = args;
35870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35871 if (!SWIG_IsOK(res1)) {
35872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35873 }
35874 arg1 = reinterpret_cast< wxWindow * >(argp1);
35875 {
35876 PyThreadState* __tstate = wxPyBeginAllowThreads();
35877 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
35878 wxPyEndAllowThreads(__tstate);
35879 if (PyErr_Occurred()) SWIG_fail;
35880 }
35881 resultobj = SWIG_From_int(static_cast< int >(result));
35882 return resultobj;
35883 fail:
35884 return NULL;
35885 }
35886
35887
35888 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35889 PyObject *resultobj = 0;
35890 wxWindow *arg1 = (wxWindow *) 0 ;
35891 bool result;
35892 void *argp1 = 0 ;
35893 int res1 = 0 ;
35894 PyObject *swig_obj[1] ;
35895
35896 if (!args) SWIG_fail;
35897 swig_obj[0] = args;
35898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35899 if (!SWIG_IsOK(res1)) {
35900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35901 }
35902 arg1 = reinterpret_cast< wxWindow * >(argp1);
35903 {
35904 PyThreadState* __tstate = wxPyBeginAllowThreads();
35905 result = (bool)(arg1)->HasTransparentBackground();
35906 wxPyEndAllowThreads(__tstate);
35907 if (PyErr_Occurred()) SWIG_fail;
35908 }
35909 {
35910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35911 }
35912 return resultobj;
35913 fail:
35914 return NULL;
35915 }
35916
35917
35918 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35919 PyObject *resultobj = 0;
35920 wxWindow *arg1 = (wxWindow *) 0 ;
35921 wxCursor *arg2 = 0 ;
35922 bool result;
35923 void *argp1 = 0 ;
35924 int res1 = 0 ;
35925 void *argp2 = 0 ;
35926 int res2 = 0 ;
35927 PyObject * obj0 = 0 ;
35928 PyObject * obj1 = 0 ;
35929 char * kwnames[] = {
35930 (char *) "self",(char *) "cursor", NULL
35931 };
35932
35933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",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_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35937 }
35938 arg1 = reinterpret_cast< wxWindow * >(argp1);
35939 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
35940 if (!SWIG_IsOK(res2)) {
35941 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35942 }
35943 if (!argp2) {
35944 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35945 }
35946 arg2 = reinterpret_cast< wxCursor * >(argp2);
35947 {
35948 PyThreadState* __tstate = wxPyBeginAllowThreads();
35949 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
35950 wxPyEndAllowThreads(__tstate);
35951 if (PyErr_Occurred()) SWIG_fail;
35952 }
35953 {
35954 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35955 }
35956 return resultobj;
35957 fail:
35958 return NULL;
35959 }
35960
35961
35962 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35963 PyObject *resultobj = 0;
35964 wxWindow *arg1 = (wxWindow *) 0 ;
35965 wxCursor result;
35966 void *argp1 = 0 ;
35967 int res1 = 0 ;
35968 PyObject *swig_obj[1] ;
35969
35970 if (!args) SWIG_fail;
35971 swig_obj[0] = args;
35972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35973 if (!SWIG_IsOK(res1)) {
35974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35975 }
35976 arg1 = reinterpret_cast< wxWindow * >(argp1);
35977 {
35978 PyThreadState* __tstate = wxPyBeginAllowThreads();
35979 result = (arg1)->GetCursor();
35980 wxPyEndAllowThreads(__tstate);
35981 if (PyErr_Occurred()) SWIG_fail;
35982 }
35983 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
35984 return resultobj;
35985 fail:
35986 return NULL;
35987 }
35988
35989
35990 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35991 PyObject *resultobj = 0;
35992 wxWindow *arg1 = (wxWindow *) 0 ;
35993 wxFont *arg2 = 0 ;
35994 bool result;
35995 void *argp1 = 0 ;
35996 int res1 = 0 ;
35997 void *argp2 = 0 ;
35998 int res2 = 0 ;
35999 PyObject * obj0 = 0 ;
36000 PyObject * obj1 = 0 ;
36001 char * kwnames[] = {
36002 (char *) "self",(char *) "font", NULL
36003 };
36004
36005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
36006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36007 if (!SWIG_IsOK(res1)) {
36008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
36009 }
36010 arg1 = reinterpret_cast< wxWindow * >(argp1);
36011 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
36012 if (!SWIG_IsOK(res2)) {
36013 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
36014 }
36015 if (!argp2) {
36016 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
36017 }
36018 arg2 = reinterpret_cast< wxFont * >(argp2);
36019 {
36020 PyThreadState* __tstate = wxPyBeginAllowThreads();
36021 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
36022 wxPyEndAllowThreads(__tstate);
36023 if (PyErr_Occurred()) SWIG_fail;
36024 }
36025 {
36026 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36027 }
36028 return resultobj;
36029 fail:
36030 return NULL;
36031 }
36032
36033
36034 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36035 PyObject *resultobj = 0;
36036 wxWindow *arg1 = (wxWindow *) 0 ;
36037 wxFont *arg2 = 0 ;
36038 void *argp1 = 0 ;
36039 int res1 = 0 ;
36040 void *argp2 = 0 ;
36041 int res2 = 0 ;
36042 PyObject * obj0 = 0 ;
36043 PyObject * obj1 = 0 ;
36044 char * kwnames[] = {
36045 (char *) "self",(char *) "font", NULL
36046 };
36047
36048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
36049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36050 if (!SWIG_IsOK(res1)) {
36051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
36052 }
36053 arg1 = reinterpret_cast< wxWindow * >(argp1);
36054 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
36055 if (!SWIG_IsOK(res2)) {
36056 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
36057 }
36058 if (!argp2) {
36059 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
36060 }
36061 arg2 = reinterpret_cast< wxFont * >(argp2);
36062 {
36063 PyThreadState* __tstate = wxPyBeginAllowThreads();
36064 (arg1)->SetOwnFont((wxFont const &)*arg2);
36065 wxPyEndAllowThreads(__tstate);
36066 if (PyErr_Occurred()) SWIG_fail;
36067 }
36068 resultobj = SWIG_Py_Void();
36069 return resultobj;
36070 fail:
36071 return NULL;
36072 }
36073
36074
36075 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36076 PyObject *resultobj = 0;
36077 wxWindow *arg1 = (wxWindow *) 0 ;
36078 wxFont result;
36079 void *argp1 = 0 ;
36080 int res1 = 0 ;
36081 PyObject *swig_obj[1] ;
36082
36083 if (!args) SWIG_fail;
36084 swig_obj[0] = args;
36085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36086 if (!SWIG_IsOK(res1)) {
36087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
36088 }
36089 arg1 = reinterpret_cast< wxWindow * >(argp1);
36090 {
36091 PyThreadState* __tstate = wxPyBeginAllowThreads();
36092 result = (arg1)->GetFont();
36093 wxPyEndAllowThreads(__tstate);
36094 if (PyErr_Occurred()) SWIG_fail;
36095 }
36096 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
36097 return resultobj;
36098 fail:
36099 return NULL;
36100 }
36101
36102
36103 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36104 PyObject *resultobj = 0;
36105 wxWindow *arg1 = (wxWindow *) 0 ;
36106 wxCaret *arg2 = (wxCaret *) 0 ;
36107 void *argp1 = 0 ;
36108 int res1 = 0 ;
36109 int res2 = 0 ;
36110 PyObject * obj0 = 0 ;
36111 PyObject * obj1 = 0 ;
36112 char * kwnames[] = {
36113 (char *) "self",(char *) "caret", NULL
36114 };
36115
36116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
36117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36118 if (!SWIG_IsOK(res1)) {
36119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
36120 }
36121 arg1 = reinterpret_cast< wxWindow * >(argp1);
36122 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
36123 if (!SWIG_IsOK(res2)) {
36124 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
36125 }
36126 {
36127 PyThreadState* __tstate = wxPyBeginAllowThreads();
36128 (arg1)->SetCaret(arg2);
36129 wxPyEndAllowThreads(__tstate);
36130 if (PyErr_Occurred()) SWIG_fail;
36131 }
36132 resultobj = SWIG_Py_Void();
36133 return resultobj;
36134 fail:
36135 return NULL;
36136 }
36137
36138
36139 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36140 PyObject *resultobj = 0;
36141 wxWindow *arg1 = (wxWindow *) 0 ;
36142 wxCaret *result = 0 ;
36143 void *argp1 = 0 ;
36144 int res1 = 0 ;
36145 PyObject *swig_obj[1] ;
36146
36147 if (!args) SWIG_fail;
36148 swig_obj[0] = args;
36149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36150 if (!SWIG_IsOK(res1)) {
36151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
36152 }
36153 arg1 = reinterpret_cast< wxWindow * >(argp1);
36154 {
36155 PyThreadState* __tstate = wxPyBeginAllowThreads();
36156 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
36157 wxPyEndAllowThreads(__tstate);
36158 if (PyErr_Occurred()) SWIG_fail;
36159 }
36160 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
36161 return resultobj;
36162 fail:
36163 return NULL;
36164 }
36165
36166
36167 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36168 PyObject *resultobj = 0;
36169 wxWindow *arg1 = (wxWindow *) 0 ;
36170 int result;
36171 void *argp1 = 0 ;
36172 int res1 = 0 ;
36173 PyObject *swig_obj[1] ;
36174
36175 if (!args) SWIG_fail;
36176 swig_obj[0] = args;
36177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36178 if (!SWIG_IsOK(res1)) {
36179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
36180 }
36181 arg1 = reinterpret_cast< wxWindow * >(argp1);
36182 {
36183 PyThreadState* __tstate = wxPyBeginAllowThreads();
36184 result = (int)((wxWindow const *)arg1)->GetCharHeight();
36185 wxPyEndAllowThreads(__tstate);
36186 if (PyErr_Occurred()) SWIG_fail;
36187 }
36188 resultobj = SWIG_From_int(static_cast< int >(result));
36189 return resultobj;
36190 fail:
36191 return NULL;
36192 }
36193
36194
36195 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36196 PyObject *resultobj = 0;
36197 wxWindow *arg1 = (wxWindow *) 0 ;
36198 int result;
36199 void *argp1 = 0 ;
36200 int res1 = 0 ;
36201 PyObject *swig_obj[1] ;
36202
36203 if (!args) SWIG_fail;
36204 swig_obj[0] = args;
36205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36206 if (!SWIG_IsOK(res1)) {
36207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
36208 }
36209 arg1 = reinterpret_cast< wxWindow * >(argp1);
36210 {
36211 PyThreadState* __tstate = wxPyBeginAllowThreads();
36212 result = (int)((wxWindow const *)arg1)->GetCharWidth();
36213 wxPyEndAllowThreads(__tstate);
36214 if (PyErr_Occurred()) SWIG_fail;
36215 }
36216 resultobj = SWIG_From_int(static_cast< int >(result));
36217 return resultobj;
36218 fail:
36219 return NULL;
36220 }
36221
36222
36223 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36224 PyObject *resultobj = 0;
36225 wxWindow *arg1 = (wxWindow *) 0 ;
36226 wxString *arg2 = 0 ;
36227 int *arg3 = (int *) 0 ;
36228 int *arg4 = (int *) 0 ;
36229 void *argp1 = 0 ;
36230 int res1 = 0 ;
36231 bool temp2 = false ;
36232 int temp3 ;
36233 int res3 = SWIG_TMPOBJ ;
36234 int temp4 ;
36235 int res4 = SWIG_TMPOBJ ;
36236 PyObject * obj0 = 0 ;
36237 PyObject * obj1 = 0 ;
36238 char * kwnames[] = {
36239 (char *) "self",(char *) "string", NULL
36240 };
36241
36242 arg3 = &temp3;
36243 arg4 = &temp4;
36244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
36245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36246 if (!SWIG_IsOK(res1)) {
36247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
36248 }
36249 arg1 = reinterpret_cast< wxWindow * >(argp1);
36250 {
36251 arg2 = wxString_in_helper(obj1);
36252 if (arg2 == NULL) SWIG_fail;
36253 temp2 = true;
36254 }
36255 {
36256 PyThreadState* __tstate = wxPyBeginAllowThreads();
36257 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
36258 wxPyEndAllowThreads(__tstate);
36259 if (PyErr_Occurred()) SWIG_fail;
36260 }
36261 resultobj = SWIG_Py_Void();
36262 if (SWIG_IsTmpObj(res3)) {
36263 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36264 } else {
36265 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36266 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36267 }
36268 if (SWIG_IsTmpObj(res4)) {
36269 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
36270 } else {
36271 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36272 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
36273 }
36274 {
36275 if (temp2)
36276 delete arg2;
36277 }
36278 return resultobj;
36279 fail:
36280 {
36281 if (temp2)
36282 delete arg2;
36283 }
36284 return NULL;
36285 }
36286
36287
36288 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36289 PyObject *resultobj = 0;
36290 wxWindow *arg1 = (wxWindow *) 0 ;
36291 wxString *arg2 = 0 ;
36292 int *arg3 = (int *) 0 ;
36293 int *arg4 = (int *) 0 ;
36294 int *arg5 = (int *) 0 ;
36295 int *arg6 = (int *) 0 ;
36296 wxFont *arg7 = (wxFont *) NULL ;
36297 void *argp1 = 0 ;
36298 int res1 = 0 ;
36299 bool temp2 = false ;
36300 int temp3 ;
36301 int res3 = SWIG_TMPOBJ ;
36302 int temp4 ;
36303 int res4 = SWIG_TMPOBJ ;
36304 int temp5 ;
36305 int res5 = SWIG_TMPOBJ ;
36306 int temp6 ;
36307 int res6 = SWIG_TMPOBJ ;
36308 void *argp7 = 0 ;
36309 int res7 = 0 ;
36310 PyObject * obj0 = 0 ;
36311 PyObject * obj1 = 0 ;
36312 PyObject * obj2 = 0 ;
36313 char * kwnames[] = {
36314 (char *) "self",(char *) "string",(char *) "font", NULL
36315 };
36316
36317 arg3 = &temp3;
36318 arg4 = &temp4;
36319 arg5 = &temp5;
36320 arg6 = &temp6;
36321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36323 if (!SWIG_IsOK(res1)) {
36324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
36325 }
36326 arg1 = reinterpret_cast< wxWindow * >(argp1);
36327 {
36328 arg2 = wxString_in_helper(obj1);
36329 if (arg2 == NULL) SWIG_fail;
36330 temp2 = true;
36331 }
36332 if (obj2) {
36333 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
36334 if (!SWIG_IsOK(res7)) {
36335 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
36336 }
36337 arg7 = reinterpret_cast< wxFont * >(argp7);
36338 }
36339 {
36340 PyThreadState* __tstate = wxPyBeginAllowThreads();
36341 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
36342 wxPyEndAllowThreads(__tstate);
36343 if (PyErr_Occurred()) SWIG_fail;
36344 }
36345 resultobj = SWIG_Py_Void();
36346 if (SWIG_IsTmpObj(res3)) {
36347 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36348 } else {
36349 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36350 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36351 }
36352 if (SWIG_IsTmpObj(res4)) {
36353 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
36354 } else {
36355 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36356 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
36357 }
36358 if (SWIG_IsTmpObj(res5)) {
36359 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
36360 } else {
36361 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36362 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
36363 }
36364 if (SWIG_IsTmpObj(res6)) {
36365 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
36366 } else {
36367 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36368 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
36369 }
36370 {
36371 if (temp2)
36372 delete arg2;
36373 }
36374 return resultobj;
36375 fail:
36376 {
36377 if (temp2)
36378 delete arg2;
36379 }
36380 return NULL;
36381 }
36382
36383
36384 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36385 PyObject *resultobj = 0;
36386 wxWindow *arg1 = (wxWindow *) 0 ;
36387 int *arg2 = (int *) 0 ;
36388 int *arg3 = (int *) 0 ;
36389 void *argp1 = 0 ;
36390 int res1 = 0 ;
36391 int temp2 ;
36392 int res2 = 0 ;
36393 int temp3 ;
36394 int res3 = 0 ;
36395 PyObject * obj0 = 0 ;
36396 PyObject * obj1 = 0 ;
36397 PyObject * obj2 = 0 ;
36398 char * kwnames[] = {
36399 (char *) "self",(char *) "x",(char *) "y", NULL
36400 };
36401
36402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36404 if (!SWIG_IsOK(res1)) {
36405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36406 }
36407 arg1 = reinterpret_cast< wxWindow * >(argp1);
36408 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
36409 int val;
36410 int ecode = SWIG_AsVal_int(obj1, &val);
36411 if (!SWIG_IsOK(ecode)) {
36412 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
36413 }
36414 temp2 = static_cast< int >(val);
36415 arg2 = &temp2;
36416 res2 = SWIG_AddTmpMask(ecode);
36417 }
36418 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
36419 int val;
36420 int ecode = SWIG_AsVal_int(obj2, &val);
36421 if (!SWIG_IsOK(ecode)) {
36422 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
36423 }
36424 temp3 = static_cast< int >(val);
36425 arg3 = &temp3;
36426 res3 = SWIG_AddTmpMask(ecode);
36427 }
36428 {
36429 PyThreadState* __tstate = wxPyBeginAllowThreads();
36430 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
36431 wxPyEndAllowThreads(__tstate);
36432 if (PyErr_Occurred()) SWIG_fail;
36433 }
36434 resultobj = SWIG_Py_Void();
36435 if (SWIG_IsTmpObj(res2)) {
36436 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
36437 } else {
36438 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36439 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
36440 }
36441 if (SWIG_IsTmpObj(res3)) {
36442 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36443 } else {
36444 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36445 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36446 }
36447 return resultobj;
36448 fail:
36449 return NULL;
36450 }
36451
36452
36453 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36454 PyObject *resultobj = 0;
36455 wxWindow *arg1 = (wxWindow *) 0 ;
36456 int *arg2 = (int *) 0 ;
36457 int *arg3 = (int *) 0 ;
36458 void *argp1 = 0 ;
36459 int res1 = 0 ;
36460 int temp2 ;
36461 int res2 = 0 ;
36462 int temp3 ;
36463 int res3 = 0 ;
36464 PyObject * obj0 = 0 ;
36465 PyObject * obj1 = 0 ;
36466 PyObject * obj2 = 0 ;
36467 char * kwnames[] = {
36468 (char *) "self",(char *) "x",(char *) "y", NULL
36469 };
36470
36471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36473 if (!SWIG_IsOK(res1)) {
36474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36475 }
36476 arg1 = reinterpret_cast< wxWindow * >(argp1);
36477 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
36478 int val;
36479 int ecode = SWIG_AsVal_int(obj1, &val);
36480 if (!SWIG_IsOK(ecode)) {
36481 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
36482 }
36483 temp2 = static_cast< int >(val);
36484 arg2 = &temp2;
36485 res2 = SWIG_AddTmpMask(ecode);
36486 }
36487 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
36488 int val;
36489 int ecode = SWIG_AsVal_int(obj2, &val);
36490 if (!SWIG_IsOK(ecode)) {
36491 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
36492 }
36493 temp3 = static_cast< int >(val);
36494 arg3 = &temp3;
36495 res3 = SWIG_AddTmpMask(ecode);
36496 }
36497 {
36498 PyThreadState* __tstate = wxPyBeginAllowThreads();
36499 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
36500 wxPyEndAllowThreads(__tstate);
36501 if (PyErr_Occurred()) SWIG_fail;
36502 }
36503 resultobj = SWIG_Py_Void();
36504 if (SWIG_IsTmpObj(res2)) {
36505 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
36506 } else {
36507 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36508 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
36509 }
36510 if (SWIG_IsTmpObj(res3)) {
36511 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36512 } else {
36513 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36514 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36515 }
36516 return resultobj;
36517 fail:
36518 return NULL;
36519 }
36520
36521
36522 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36523 PyObject *resultobj = 0;
36524 wxWindow *arg1 = (wxWindow *) 0 ;
36525 wxPoint *arg2 = 0 ;
36526 wxPoint result;
36527 void *argp1 = 0 ;
36528 int res1 = 0 ;
36529 wxPoint temp2 ;
36530 PyObject * obj0 = 0 ;
36531 PyObject * obj1 = 0 ;
36532 char * kwnames[] = {
36533 (char *) "self",(char *) "pt", NULL
36534 };
36535
36536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
36537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36538 if (!SWIG_IsOK(res1)) {
36539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
36540 }
36541 arg1 = reinterpret_cast< wxWindow * >(argp1);
36542 {
36543 arg2 = &temp2;
36544 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36545 }
36546 {
36547 PyThreadState* __tstate = wxPyBeginAllowThreads();
36548 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
36549 wxPyEndAllowThreads(__tstate);
36550 if (PyErr_Occurred()) SWIG_fail;
36551 }
36552 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
36553 return resultobj;
36554 fail:
36555 return NULL;
36556 }
36557
36558
36559 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36560 PyObject *resultobj = 0;
36561 wxWindow *arg1 = (wxWindow *) 0 ;
36562 wxPoint *arg2 = 0 ;
36563 wxPoint result;
36564 void *argp1 = 0 ;
36565 int res1 = 0 ;
36566 wxPoint temp2 ;
36567 PyObject * obj0 = 0 ;
36568 PyObject * obj1 = 0 ;
36569 char * kwnames[] = {
36570 (char *) "self",(char *) "pt", NULL
36571 };
36572
36573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
36574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36575 if (!SWIG_IsOK(res1)) {
36576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
36577 }
36578 arg1 = reinterpret_cast< wxWindow * >(argp1);
36579 {
36580 arg2 = &temp2;
36581 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36582 }
36583 {
36584 PyThreadState* __tstate = wxPyBeginAllowThreads();
36585 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
36586 wxPyEndAllowThreads(__tstate);
36587 if (PyErr_Occurred()) SWIG_fail;
36588 }
36589 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
36590 return resultobj;
36591 fail:
36592 return NULL;
36593 }
36594
36595
36596 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36597 PyObject *resultobj = 0;
36598 wxWindow *arg1 = (wxWindow *) 0 ;
36599 int arg2 ;
36600 int arg3 ;
36601 wxHitTest result;
36602 void *argp1 = 0 ;
36603 int res1 = 0 ;
36604 int val2 ;
36605 int ecode2 = 0 ;
36606 int val3 ;
36607 int ecode3 = 0 ;
36608 PyObject * obj0 = 0 ;
36609 PyObject * obj1 = 0 ;
36610 PyObject * obj2 = 0 ;
36611 char * kwnames[] = {
36612 (char *) "self",(char *) "x",(char *) "y", NULL
36613 };
36614
36615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36617 if (!SWIG_IsOK(res1)) {
36618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36619 }
36620 arg1 = reinterpret_cast< wxWindow * >(argp1);
36621 ecode2 = SWIG_AsVal_int(obj1, &val2);
36622 if (!SWIG_IsOK(ecode2)) {
36623 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
36624 }
36625 arg2 = static_cast< int >(val2);
36626 ecode3 = SWIG_AsVal_int(obj2, &val3);
36627 if (!SWIG_IsOK(ecode3)) {
36628 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
36629 }
36630 arg3 = static_cast< int >(val3);
36631 {
36632 PyThreadState* __tstate = wxPyBeginAllowThreads();
36633 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
36634 wxPyEndAllowThreads(__tstate);
36635 if (PyErr_Occurred()) SWIG_fail;
36636 }
36637 resultobj = SWIG_From_int(static_cast< int >(result));
36638 return resultobj;
36639 fail:
36640 return NULL;
36641 }
36642
36643
36644 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36645 PyObject *resultobj = 0;
36646 wxWindow *arg1 = (wxWindow *) 0 ;
36647 wxPoint *arg2 = 0 ;
36648 wxHitTest result;
36649 void *argp1 = 0 ;
36650 int res1 = 0 ;
36651 wxPoint temp2 ;
36652 PyObject * obj0 = 0 ;
36653 PyObject * obj1 = 0 ;
36654 char * kwnames[] = {
36655 (char *) "self",(char *) "pt", NULL
36656 };
36657
36658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
36659 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36660 if (!SWIG_IsOK(res1)) {
36661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
36662 }
36663 arg1 = reinterpret_cast< wxWindow * >(argp1);
36664 {
36665 arg2 = &temp2;
36666 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36667 }
36668 {
36669 PyThreadState* __tstate = wxPyBeginAllowThreads();
36670 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
36671 wxPyEndAllowThreads(__tstate);
36672 if (PyErr_Occurred()) SWIG_fail;
36673 }
36674 resultobj = SWIG_From_int(static_cast< int >(result));
36675 return resultobj;
36676 fail:
36677 return NULL;
36678 }
36679
36680
36681 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
36682 PyObject *resultobj = 0;
36683 wxWindow *arg1 = (wxWindow *) 0 ;
36684 long arg2 ;
36685 wxBorder result;
36686 void *argp1 = 0 ;
36687 int res1 = 0 ;
36688 long val2 ;
36689 int ecode2 = 0 ;
36690
36691 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
36692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36693 if (!SWIG_IsOK(res1)) {
36694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
36695 }
36696 arg1 = reinterpret_cast< wxWindow * >(argp1);
36697 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
36698 if (!SWIG_IsOK(ecode2)) {
36699 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
36700 }
36701 arg2 = static_cast< long >(val2);
36702 {
36703 PyThreadState* __tstate = wxPyBeginAllowThreads();
36704 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
36705 wxPyEndAllowThreads(__tstate);
36706 if (PyErr_Occurred()) SWIG_fail;
36707 }
36708 resultobj = SWIG_From_int(static_cast< int >(result));
36709 return resultobj;
36710 fail:
36711 return NULL;
36712 }
36713
36714
36715 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
36716 PyObject *resultobj = 0;
36717 wxWindow *arg1 = (wxWindow *) 0 ;
36718 wxBorder result;
36719 void *argp1 = 0 ;
36720 int res1 = 0 ;
36721
36722 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
36723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36724 if (!SWIG_IsOK(res1)) {
36725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
36726 }
36727 arg1 = reinterpret_cast< wxWindow * >(argp1);
36728 {
36729 PyThreadState* __tstate = wxPyBeginAllowThreads();
36730 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
36731 wxPyEndAllowThreads(__tstate);
36732 if (PyErr_Occurred()) SWIG_fail;
36733 }
36734 resultobj = SWIG_From_int(static_cast< int >(result));
36735 return resultobj;
36736 fail:
36737 return NULL;
36738 }
36739
36740
36741 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
36742 int argc;
36743 PyObject *argv[3];
36744
36745 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
36746 --argc;
36747 if (argc == 1) {
36748 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
36749 }
36750 if (argc == 2) {
36751 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
36752 }
36753
36754 fail:
36755 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
36756 return NULL;
36757 }
36758
36759
36760 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36761 PyObject *resultobj = 0;
36762 wxWindow *arg1 = (wxWindow *) 0 ;
36763 long arg2 = (long) wxUPDATE_UI_NONE ;
36764 void *argp1 = 0 ;
36765 int res1 = 0 ;
36766 long val2 ;
36767 int ecode2 = 0 ;
36768 PyObject * obj0 = 0 ;
36769 PyObject * obj1 = 0 ;
36770 char * kwnames[] = {
36771 (char *) "self",(char *) "flags", NULL
36772 };
36773
36774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
36775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36776 if (!SWIG_IsOK(res1)) {
36777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
36778 }
36779 arg1 = reinterpret_cast< wxWindow * >(argp1);
36780 if (obj1) {
36781 ecode2 = SWIG_AsVal_long(obj1, &val2);
36782 if (!SWIG_IsOK(ecode2)) {
36783 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
36784 }
36785 arg2 = static_cast< long >(val2);
36786 }
36787 {
36788 PyThreadState* __tstate = wxPyBeginAllowThreads();
36789 (arg1)->UpdateWindowUI(arg2);
36790 wxPyEndAllowThreads(__tstate);
36791 if (PyErr_Occurred()) SWIG_fail;
36792 }
36793 resultobj = SWIG_Py_Void();
36794 return resultobj;
36795 fail:
36796 return NULL;
36797 }
36798
36799
36800 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36801 PyObject *resultobj = 0;
36802 wxWindow *arg1 = (wxWindow *) 0 ;
36803 wxMenu *arg2 = (wxMenu *) 0 ;
36804 int arg3 = (int) -1 ;
36805 int arg4 = (int) -1 ;
36806 bool result;
36807 void *argp1 = 0 ;
36808 int res1 = 0 ;
36809 void *argp2 = 0 ;
36810 int res2 = 0 ;
36811 int val3 ;
36812 int ecode3 = 0 ;
36813 int val4 ;
36814 int ecode4 = 0 ;
36815 PyObject * obj0 = 0 ;
36816 PyObject * obj1 = 0 ;
36817 PyObject * obj2 = 0 ;
36818 PyObject * obj3 = 0 ;
36819 char * kwnames[] = {
36820 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
36821 };
36822
36823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36825 if (!SWIG_IsOK(res1)) {
36826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
36827 }
36828 arg1 = reinterpret_cast< wxWindow * >(argp1);
36829 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36830 if (!SWIG_IsOK(res2)) {
36831 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
36832 }
36833 arg2 = reinterpret_cast< wxMenu * >(argp2);
36834 if (obj2) {
36835 ecode3 = SWIG_AsVal_int(obj2, &val3);
36836 if (!SWIG_IsOK(ecode3)) {
36837 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
36838 }
36839 arg3 = static_cast< int >(val3);
36840 }
36841 if (obj3) {
36842 ecode4 = SWIG_AsVal_int(obj3, &val4);
36843 if (!SWIG_IsOK(ecode4)) {
36844 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
36845 }
36846 arg4 = static_cast< int >(val4);
36847 }
36848 {
36849 PyThreadState* __tstate = wxPyBeginAllowThreads();
36850 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
36851 wxPyEndAllowThreads(__tstate);
36852 if (PyErr_Occurred()) SWIG_fail;
36853 }
36854 {
36855 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36856 }
36857 return resultobj;
36858 fail:
36859 return NULL;
36860 }
36861
36862
36863 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36864 PyObject *resultobj = 0;
36865 wxWindow *arg1 = (wxWindow *) 0 ;
36866 wxMenu *arg2 = (wxMenu *) 0 ;
36867 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36868 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36869 bool result;
36870 void *argp1 = 0 ;
36871 int res1 = 0 ;
36872 void *argp2 = 0 ;
36873 int res2 = 0 ;
36874 wxPoint temp3 ;
36875 PyObject * obj0 = 0 ;
36876 PyObject * obj1 = 0 ;
36877 PyObject * obj2 = 0 ;
36878 char * kwnames[] = {
36879 (char *) "self",(char *) "menu",(char *) "pos", NULL
36880 };
36881
36882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36884 if (!SWIG_IsOK(res1)) {
36885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
36886 }
36887 arg1 = reinterpret_cast< wxWindow * >(argp1);
36888 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36889 if (!SWIG_IsOK(res2)) {
36890 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
36891 }
36892 arg2 = reinterpret_cast< wxMenu * >(argp2);
36893 if (obj2) {
36894 {
36895 arg3 = &temp3;
36896 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36897 }
36898 }
36899 {
36900 PyThreadState* __tstate = wxPyBeginAllowThreads();
36901 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
36902 wxPyEndAllowThreads(__tstate);
36903 if (PyErr_Occurred()) SWIG_fail;
36904 }
36905 {
36906 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36907 }
36908 return resultobj;
36909 fail:
36910 return NULL;
36911 }
36912
36913
36914 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36915 PyObject *resultobj = 0;
36916 wxWindow *arg1 = (wxWindow *) 0 ;
36917 bool result;
36918 void *argp1 = 0 ;
36919 int res1 = 0 ;
36920 PyObject *swig_obj[1] ;
36921
36922 if (!args) SWIG_fail;
36923 swig_obj[0] = args;
36924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36925 if (!SWIG_IsOK(res1)) {
36926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
36927 }
36928 arg1 = reinterpret_cast< wxWindow * >(argp1);
36929 {
36930 PyThreadState* __tstate = wxPyBeginAllowThreads();
36931 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
36932 wxPyEndAllowThreads(__tstate);
36933 if (PyErr_Occurred()) SWIG_fail;
36934 }
36935 {
36936 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36937 }
36938 return resultobj;
36939 fail:
36940 return NULL;
36941 }
36942
36943
36944 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36945 PyObject *resultobj = 0;
36946 wxWindow *arg1 = (wxWindow *) 0 ;
36947 long result;
36948 void *argp1 = 0 ;
36949 int res1 = 0 ;
36950 PyObject *swig_obj[1] ;
36951
36952 if (!args) SWIG_fail;
36953 swig_obj[0] = args;
36954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36955 if (!SWIG_IsOK(res1)) {
36956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36957 }
36958 arg1 = reinterpret_cast< wxWindow * >(argp1);
36959 {
36960 PyThreadState* __tstate = wxPyBeginAllowThreads();
36961 result = (long)wxWindow_GetHandle(arg1);
36962 wxPyEndAllowThreads(__tstate);
36963 if (PyErr_Occurred()) SWIG_fail;
36964 }
36965 resultobj = SWIG_From_long(static_cast< long >(result));
36966 return resultobj;
36967 fail:
36968 return NULL;
36969 }
36970
36971
36972 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36973 PyObject *resultobj = 0;
36974 wxWindow *arg1 = (wxWindow *) 0 ;
36975 long arg2 ;
36976 void *argp1 = 0 ;
36977 int res1 = 0 ;
36978 long val2 ;
36979 int ecode2 = 0 ;
36980 PyObject * obj0 = 0 ;
36981 PyObject * obj1 = 0 ;
36982 char * kwnames[] = {
36983 (char *) "self",(char *) "handle", NULL
36984 };
36985
36986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",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_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36990 }
36991 arg1 = reinterpret_cast< wxWindow * >(argp1);
36992 ecode2 = SWIG_AsVal_long(obj1, &val2);
36993 if (!SWIG_IsOK(ecode2)) {
36994 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
36995 }
36996 arg2 = static_cast< long >(val2);
36997 {
36998 PyThreadState* __tstate = wxPyBeginAllowThreads();
36999 wxWindow_AssociateHandle(arg1,arg2);
37000 wxPyEndAllowThreads(__tstate);
37001 if (PyErr_Occurred()) SWIG_fail;
37002 }
37003 resultobj = SWIG_Py_Void();
37004 return resultobj;
37005 fail:
37006 return NULL;
37007 }
37008
37009
37010 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37011 PyObject *resultobj = 0;
37012 wxWindow *arg1 = (wxWindow *) 0 ;
37013 void *argp1 = 0 ;
37014 int res1 = 0 ;
37015 PyObject *swig_obj[1] ;
37016
37017 if (!args) SWIG_fail;
37018 swig_obj[0] = args;
37019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37020 if (!SWIG_IsOK(res1)) {
37021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
37022 }
37023 arg1 = reinterpret_cast< wxWindow * >(argp1);
37024 {
37025 PyThreadState* __tstate = wxPyBeginAllowThreads();
37026 (arg1)->DissociateHandle();
37027 wxPyEndAllowThreads(__tstate);
37028 if (PyErr_Occurred()) SWIG_fail;
37029 }
37030 resultobj = SWIG_Py_Void();
37031 return resultobj;
37032 fail:
37033 return NULL;
37034 }
37035
37036
37037 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37038 PyObject *resultobj = 0;
37039 wxWindow *arg1 = (wxWindow *) 0 ;
37040 int arg2 ;
37041 bool result;
37042 void *argp1 = 0 ;
37043 int res1 = 0 ;
37044 int val2 ;
37045 int ecode2 = 0 ;
37046 PyObject * obj0 = 0 ;
37047 PyObject * obj1 = 0 ;
37048 char * kwnames[] = {
37049 (char *) "self",(char *) "orient", NULL
37050 };
37051
37052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
37053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37054 if (!SWIG_IsOK(res1)) {
37055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
37056 }
37057 arg1 = reinterpret_cast< wxWindow * >(argp1);
37058 ecode2 = SWIG_AsVal_int(obj1, &val2);
37059 if (!SWIG_IsOK(ecode2)) {
37060 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
37061 }
37062 arg2 = static_cast< int >(val2);
37063 {
37064 PyThreadState* __tstate = wxPyBeginAllowThreads();
37065 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
37066 wxPyEndAllowThreads(__tstate);
37067 if (PyErr_Occurred()) SWIG_fail;
37068 }
37069 {
37070 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37071 }
37072 return resultobj;
37073 fail:
37074 return NULL;
37075 }
37076
37077
37078 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37079 PyObject *resultobj = 0;
37080 wxWindow *arg1 = (wxWindow *) 0 ;
37081 int arg2 ;
37082 int arg3 ;
37083 int arg4 ;
37084 int arg5 ;
37085 bool arg6 = (bool) true ;
37086 void *argp1 = 0 ;
37087 int res1 = 0 ;
37088 int val2 ;
37089 int ecode2 = 0 ;
37090 int val3 ;
37091 int ecode3 = 0 ;
37092 int val4 ;
37093 int ecode4 = 0 ;
37094 int val5 ;
37095 int ecode5 = 0 ;
37096 bool val6 ;
37097 int ecode6 = 0 ;
37098 PyObject * obj0 = 0 ;
37099 PyObject * obj1 = 0 ;
37100 PyObject * obj2 = 0 ;
37101 PyObject * obj3 = 0 ;
37102 PyObject * obj4 = 0 ;
37103 PyObject * obj5 = 0 ;
37104 char * kwnames[] = {
37105 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
37106 };
37107
37108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
37109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37110 if (!SWIG_IsOK(res1)) {
37111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
37112 }
37113 arg1 = reinterpret_cast< wxWindow * >(argp1);
37114 ecode2 = SWIG_AsVal_int(obj1, &val2);
37115 if (!SWIG_IsOK(ecode2)) {
37116 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
37117 }
37118 arg2 = static_cast< int >(val2);
37119 ecode3 = SWIG_AsVal_int(obj2, &val3);
37120 if (!SWIG_IsOK(ecode3)) {
37121 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
37122 }
37123 arg3 = static_cast< int >(val3);
37124 ecode4 = SWIG_AsVal_int(obj3, &val4);
37125 if (!SWIG_IsOK(ecode4)) {
37126 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
37127 }
37128 arg4 = static_cast< int >(val4);
37129 ecode5 = SWIG_AsVal_int(obj4, &val5);
37130 if (!SWIG_IsOK(ecode5)) {
37131 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
37132 }
37133 arg5 = static_cast< int >(val5);
37134 if (obj5) {
37135 ecode6 = SWIG_AsVal_bool(obj5, &val6);
37136 if (!SWIG_IsOK(ecode6)) {
37137 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
37138 }
37139 arg6 = static_cast< bool >(val6);
37140 }
37141 {
37142 PyThreadState* __tstate = wxPyBeginAllowThreads();
37143 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
37144 wxPyEndAllowThreads(__tstate);
37145 if (PyErr_Occurred()) SWIG_fail;
37146 }
37147 resultobj = SWIG_Py_Void();
37148 return resultobj;
37149 fail:
37150 return NULL;
37151 }
37152
37153
37154 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37155 PyObject *resultobj = 0;
37156 wxWindow *arg1 = (wxWindow *) 0 ;
37157 int arg2 ;
37158 int arg3 ;
37159 bool arg4 = (bool) true ;
37160 void *argp1 = 0 ;
37161 int res1 = 0 ;
37162 int val2 ;
37163 int ecode2 = 0 ;
37164 int val3 ;
37165 int ecode3 = 0 ;
37166 bool val4 ;
37167 int ecode4 = 0 ;
37168 PyObject * obj0 = 0 ;
37169 PyObject * obj1 = 0 ;
37170 PyObject * obj2 = 0 ;
37171 PyObject * obj3 = 0 ;
37172 char * kwnames[] = {
37173 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
37174 };
37175
37176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37178 if (!SWIG_IsOK(res1)) {
37179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
37180 }
37181 arg1 = reinterpret_cast< wxWindow * >(argp1);
37182 ecode2 = SWIG_AsVal_int(obj1, &val2);
37183 if (!SWIG_IsOK(ecode2)) {
37184 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
37185 }
37186 arg2 = static_cast< int >(val2);
37187 ecode3 = SWIG_AsVal_int(obj2, &val3);
37188 if (!SWIG_IsOK(ecode3)) {
37189 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
37190 }
37191 arg3 = static_cast< int >(val3);
37192 if (obj3) {
37193 ecode4 = SWIG_AsVal_bool(obj3, &val4);
37194 if (!SWIG_IsOK(ecode4)) {
37195 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
37196 }
37197 arg4 = static_cast< bool >(val4);
37198 }
37199 {
37200 PyThreadState* __tstate = wxPyBeginAllowThreads();
37201 (arg1)->SetScrollPos(arg2,arg3,arg4);
37202 wxPyEndAllowThreads(__tstate);
37203 if (PyErr_Occurred()) SWIG_fail;
37204 }
37205 resultobj = SWIG_Py_Void();
37206 return resultobj;
37207 fail:
37208 return NULL;
37209 }
37210
37211
37212 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37213 PyObject *resultobj = 0;
37214 wxWindow *arg1 = (wxWindow *) 0 ;
37215 int arg2 ;
37216 int result;
37217 void *argp1 = 0 ;
37218 int res1 = 0 ;
37219 int val2 ;
37220 int ecode2 = 0 ;
37221 PyObject * obj0 = 0 ;
37222 PyObject * obj1 = 0 ;
37223 char * kwnames[] = {
37224 (char *) "self",(char *) "orientation", NULL
37225 };
37226
37227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
37228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37229 if (!SWIG_IsOK(res1)) {
37230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
37231 }
37232 arg1 = reinterpret_cast< wxWindow * >(argp1);
37233 ecode2 = SWIG_AsVal_int(obj1, &val2);
37234 if (!SWIG_IsOK(ecode2)) {
37235 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
37236 }
37237 arg2 = static_cast< int >(val2);
37238 {
37239 PyThreadState* __tstate = wxPyBeginAllowThreads();
37240 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
37241 wxPyEndAllowThreads(__tstate);
37242 if (PyErr_Occurred()) SWIG_fail;
37243 }
37244 resultobj = SWIG_From_int(static_cast< int >(result));
37245 return resultobj;
37246 fail:
37247 return NULL;
37248 }
37249
37250
37251 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37252 PyObject *resultobj = 0;
37253 wxWindow *arg1 = (wxWindow *) 0 ;
37254 int arg2 ;
37255 int result;
37256 void *argp1 = 0 ;
37257 int res1 = 0 ;
37258 int val2 ;
37259 int ecode2 = 0 ;
37260 PyObject * obj0 = 0 ;
37261 PyObject * obj1 = 0 ;
37262 char * kwnames[] = {
37263 (char *) "self",(char *) "orientation", NULL
37264 };
37265
37266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
37267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37268 if (!SWIG_IsOK(res1)) {
37269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
37270 }
37271 arg1 = reinterpret_cast< wxWindow * >(argp1);
37272 ecode2 = SWIG_AsVal_int(obj1, &val2);
37273 if (!SWIG_IsOK(ecode2)) {
37274 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
37275 }
37276 arg2 = static_cast< int >(val2);
37277 {
37278 PyThreadState* __tstate = wxPyBeginAllowThreads();
37279 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
37280 wxPyEndAllowThreads(__tstate);
37281 if (PyErr_Occurred()) SWIG_fail;
37282 }
37283 resultobj = SWIG_From_int(static_cast< int >(result));
37284 return resultobj;
37285 fail:
37286 return NULL;
37287 }
37288
37289
37290 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37291 PyObject *resultobj = 0;
37292 wxWindow *arg1 = (wxWindow *) 0 ;
37293 int arg2 ;
37294 int result;
37295 void *argp1 = 0 ;
37296 int res1 = 0 ;
37297 int val2 ;
37298 int ecode2 = 0 ;
37299 PyObject * obj0 = 0 ;
37300 PyObject * obj1 = 0 ;
37301 char * kwnames[] = {
37302 (char *) "self",(char *) "orientation", NULL
37303 };
37304
37305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
37306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37307 if (!SWIG_IsOK(res1)) {
37308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
37309 }
37310 arg1 = reinterpret_cast< wxWindow * >(argp1);
37311 ecode2 = SWIG_AsVal_int(obj1, &val2);
37312 if (!SWIG_IsOK(ecode2)) {
37313 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
37314 }
37315 arg2 = static_cast< int >(val2);
37316 {
37317 PyThreadState* __tstate = wxPyBeginAllowThreads();
37318 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
37319 wxPyEndAllowThreads(__tstate);
37320 if (PyErr_Occurred()) SWIG_fail;
37321 }
37322 resultobj = SWIG_From_int(static_cast< int >(result));
37323 return resultobj;
37324 fail:
37325 return NULL;
37326 }
37327
37328
37329 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37330 PyObject *resultobj = 0;
37331 wxWindow *arg1 = (wxWindow *) 0 ;
37332 int arg2 ;
37333 int arg3 ;
37334 wxRect *arg4 = (wxRect *) NULL ;
37335 void *argp1 = 0 ;
37336 int res1 = 0 ;
37337 int val2 ;
37338 int ecode2 = 0 ;
37339 int val3 ;
37340 int ecode3 = 0 ;
37341 void *argp4 = 0 ;
37342 int res4 = 0 ;
37343 PyObject * obj0 = 0 ;
37344 PyObject * obj1 = 0 ;
37345 PyObject * obj2 = 0 ;
37346 PyObject * obj3 = 0 ;
37347 char * kwnames[] = {
37348 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
37349 };
37350
37351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37353 if (!SWIG_IsOK(res1)) {
37354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
37355 }
37356 arg1 = reinterpret_cast< wxWindow * >(argp1);
37357 ecode2 = SWIG_AsVal_int(obj1, &val2);
37358 if (!SWIG_IsOK(ecode2)) {
37359 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
37360 }
37361 arg2 = static_cast< int >(val2);
37362 ecode3 = SWIG_AsVal_int(obj2, &val3);
37363 if (!SWIG_IsOK(ecode3)) {
37364 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
37365 }
37366 arg3 = static_cast< int >(val3);
37367 if (obj3) {
37368 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
37369 if (!SWIG_IsOK(res4)) {
37370 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
37371 }
37372 arg4 = reinterpret_cast< wxRect * >(argp4);
37373 }
37374 {
37375 PyThreadState* __tstate = wxPyBeginAllowThreads();
37376 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
37377 wxPyEndAllowThreads(__tstate);
37378 if (PyErr_Occurred()) SWIG_fail;
37379 }
37380 resultobj = SWIG_Py_Void();
37381 return resultobj;
37382 fail:
37383 return NULL;
37384 }
37385
37386
37387 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37388 PyObject *resultobj = 0;
37389 wxWindow *arg1 = (wxWindow *) 0 ;
37390 int arg2 ;
37391 bool result;
37392 void *argp1 = 0 ;
37393 int res1 = 0 ;
37394 int val2 ;
37395 int ecode2 = 0 ;
37396 PyObject * obj0 = 0 ;
37397 PyObject * obj1 = 0 ;
37398 char * kwnames[] = {
37399 (char *) "self",(char *) "lines", NULL
37400 };
37401
37402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
37403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37404 if (!SWIG_IsOK(res1)) {
37405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
37406 }
37407 arg1 = reinterpret_cast< wxWindow * >(argp1);
37408 ecode2 = SWIG_AsVal_int(obj1, &val2);
37409 if (!SWIG_IsOK(ecode2)) {
37410 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
37411 }
37412 arg2 = static_cast< int >(val2);
37413 {
37414 PyThreadState* __tstate = wxPyBeginAllowThreads();
37415 result = (bool)(arg1)->ScrollLines(arg2);
37416 wxPyEndAllowThreads(__tstate);
37417 if (PyErr_Occurred()) SWIG_fail;
37418 }
37419 {
37420 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37421 }
37422 return resultobj;
37423 fail:
37424 return NULL;
37425 }
37426
37427
37428 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37429 PyObject *resultobj = 0;
37430 wxWindow *arg1 = (wxWindow *) 0 ;
37431 int arg2 ;
37432 bool result;
37433 void *argp1 = 0 ;
37434 int res1 = 0 ;
37435 int val2 ;
37436 int ecode2 = 0 ;
37437 PyObject * obj0 = 0 ;
37438 PyObject * obj1 = 0 ;
37439 char * kwnames[] = {
37440 (char *) "self",(char *) "pages", NULL
37441 };
37442
37443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
37444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37445 if (!SWIG_IsOK(res1)) {
37446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
37447 }
37448 arg1 = reinterpret_cast< wxWindow * >(argp1);
37449 ecode2 = SWIG_AsVal_int(obj1, &val2);
37450 if (!SWIG_IsOK(ecode2)) {
37451 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
37452 }
37453 arg2 = static_cast< int >(val2);
37454 {
37455 PyThreadState* __tstate = wxPyBeginAllowThreads();
37456 result = (bool)(arg1)->ScrollPages(arg2);
37457 wxPyEndAllowThreads(__tstate);
37458 if (PyErr_Occurred()) SWIG_fail;
37459 }
37460 {
37461 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37462 }
37463 return resultobj;
37464 fail:
37465 return NULL;
37466 }
37467
37468
37469 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37470 PyObject *resultobj = 0;
37471 wxWindow *arg1 = (wxWindow *) 0 ;
37472 bool result;
37473 void *argp1 = 0 ;
37474 int res1 = 0 ;
37475 PyObject *swig_obj[1] ;
37476
37477 if (!args) SWIG_fail;
37478 swig_obj[0] = args;
37479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37480 if (!SWIG_IsOK(res1)) {
37481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
37482 }
37483 arg1 = reinterpret_cast< wxWindow * >(argp1);
37484 {
37485 PyThreadState* __tstate = wxPyBeginAllowThreads();
37486 result = (bool)(arg1)->LineUp();
37487 wxPyEndAllowThreads(__tstate);
37488 if (PyErr_Occurred()) SWIG_fail;
37489 }
37490 {
37491 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37492 }
37493 return resultobj;
37494 fail:
37495 return NULL;
37496 }
37497
37498
37499 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37500 PyObject *resultobj = 0;
37501 wxWindow *arg1 = (wxWindow *) 0 ;
37502 bool result;
37503 void *argp1 = 0 ;
37504 int res1 = 0 ;
37505 PyObject *swig_obj[1] ;
37506
37507 if (!args) SWIG_fail;
37508 swig_obj[0] = args;
37509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37510 if (!SWIG_IsOK(res1)) {
37511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
37512 }
37513 arg1 = reinterpret_cast< wxWindow * >(argp1);
37514 {
37515 PyThreadState* __tstate = wxPyBeginAllowThreads();
37516 result = (bool)(arg1)->LineDown();
37517 wxPyEndAllowThreads(__tstate);
37518 if (PyErr_Occurred()) SWIG_fail;
37519 }
37520 {
37521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37522 }
37523 return resultobj;
37524 fail:
37525 return NULL;
37526 }
37527
37528
37529 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37530 PyObject *resultobj = 0;
37531 wxWindow *arg1 = (wxWindow *) 0 ;
37532 bool result;
37533 void *argp1 = 0 ;
37534 int res1 = 0 ;
37535 PyObject *swig_obj[1] ;
37536
37537 if (!args) SWIG_fail;
37538 swig_obj[0] = args;
37539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37540 if (!SWIG_IsOK(res1)) {
37541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
37542 }
37543 arg1 = reinterpret_cast< wxWindow * >(argp1);
37544 {
37545 PyThreadState* __tstate = wxPyBeginAllowThreads();
37546 result = (bool)(arg1)->PageUp();
37547 wxPyEndAllowThreads(__tstate);
37548 if (PyErr_Occurred()) SWIG_fail;
37549 }
37550 {
37551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37552 }
37553 return resultobj;
37554 fail:
37555 return NULL;
37556 }
37557
37558
37559 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37560 PyObject *resultobj = 0;
37561 wxWindow *arg1 = (wxWindow *) 0 ;
37562 bool result;
37563 void *argp1 = 0 ;
37564 int res1 = 0 ;
37565 PyObject *swig_obj[1] ;
37566
37567 if (!args) SWIG_fail;
37568 swig_obj[0] = args;
37569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37570 if (!SWIG_IsOK(res1)) {
37571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
37572 }
37573 arg1 = reinterpret_cast< wxWindow * >(argp1);
37574 {
37575 PyThreadState* __tstate = wxPyBeginAllowThreads();
37576 result = (bool)(arg1)->PageDown();
37577 wxPyEndAllowThreads(__tstate);
37578 if (PyErr_Occurred()) SWIG_fail;
37579 }
37580 {
37581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37582 }
37583 return resultobj;
37584 fail:
37585 return NULL;
37586 }
37587
37588
37589 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37590 PyObject *resultobj = 0;
37591 wxWindow *arg1 = (wxWindow *) 0 ;
37592 wxString *arg2 = 0 ;
37593 void *argp1 = 0 ;
37594 int res1 = 0 ;
37595 bool temp2 = false ;
37596 PyObject * obj0 = 0 ;
37597 PyObject * obj1 = 0 ;
37598 char * kwnames[] = {
37599 (char *) "self",(char *) "text", NULL
37600 };
37601
37602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
37603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37604 if (!SWIG_IsOK(res1)) {
37605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
37606 }
37607 arg1 = reinterpret_cast< wxWindow * >(argp1);
37608 {
37609 arg2 = wxString_in_helper(obj1);
37610 if (arg2 == NULL) SWIG_fail;
37611 temp2 = true;
37612 }
37613 {
37614 PyThreadState* __tstate = wxPyBeginAllowThreads();
37615 (arg1)->SetHelpText((wxString const &)*arg2);
37616 wxPyEndAllowThreads(__tstate);
37617 if (PyErr_Occurred()) SWIG_fail;
37618 }
37619 resultobj = SWIG_Py_Void();
37620 {
37621 if (temp2)
37622 delete arg2;
37623 }
37624 return resultobj;
37625 fail:
37626 {
37627 if (temp2)
37628 delete arg2;
37629 }
37630 return NULL;
37631 }
37632
37633
37634 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37635 PyObject *resultobj = 0;
37636 wxWindow *arg1 = (wxWindow *) 0 ;
37637 wxString *arg2 = 0 ;
37638 void *argp1 = 0 ;
37639 int res1 = 0 ;
37640 bool temp2 = false ;
37641 PyObject * obj0 = 0 ;
37642 PyObject * obj1 = 0 ;
37643 char * kwnames[] = {
37644 (char *) "self",(char *) "text", NULL
37645 };
37646
37647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
37648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37649 if (!SWIG_IsOK(res1)) {
37650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
37651 }
37652 arg1 = reinterpret_cast< wxWindow * >(argp1);
37653 {
37654 arg2 = wxString_in_helper(obj1);
37655 if (arg2 == NULL) SWIG_fail;
37656 temp2 = true;
37657 }
37658 {
37659 PyThreadState* __tstate = wxPyBeginAllowThreads();
37660 (arg1)->SetHelpTextForId((wxString const &)*arg2);
37661 wxPyEndAllowThreads(__tstate);
37662 if (PyErr_Occurred()) SWIG_fail;
37663 }
37664 resultobj = SWIG_Py_Void();
37665 {
37666 if (temp2)
37667 delete arg2;
37668 }
37669 return resultobj;
37670 fail:
37671 {
37672 if (temp2)
37673 delete arg2;
37674 }
37675 return NULL;
37676 }
37677
37678
37679 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37680 PyObject *resultobj = 0;
37681 wxWindow *arg1 = (wxWindow *) 0 ;
37682 wxPoint *arg2 = 0 ;
37683 wxHelpEvent::Origin arg3 ;
37684 wxString result;
37685 void *argp1 = 0 ;
37686 int res1 = 0 ;
37687 wxPoint temp2 ;
37688 void *argp3 ;
37689 int res3 = 0 ;
37690 PyObject * obj0 = 0 ;
37691 PyObject * obj1 = 0 ;
37692 PyObject * obj2 = 0 ;
37693 char * kwnames[] = {
37694 (char *) "self",(char *) "pt",(char *) "origin", NULL
37695 };
37696
37697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37698 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37699 if (!SWIG_IsOK(res1)) {
37700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
37701 }
37702 arg1 = reinterpret_cast< wxWindow * >(argp1);
37703 {
37704 arg2 = &temp2;
37705 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37706 }
37707 {
37708 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
37709 if (!SWIG_IsOK(res3)) {
37710 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
37711 }
37712 if (!argp3) {
37713 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
37714 } else {
37715 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
37716 arg3 = *temp;
37717 if (SWIG_IsNewObj(res3)) delete temp;
37718 }
37719 }
37720 {
37721 PyThreadState* __tstate = wxPyBeginAllowThreads();
37722 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
37723 wxPyEndAllowThreads(__tstate);
37724 if (PyErr_Occurred()) SWIG_fail;
37725 }
37726 {
37727 #if wxUSE_UNICODE
37728 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37729 #else
37730 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37731 #endif
37732 }
37733 return resultobj;
37734 fail:
37735 return NULL;
37736 }
37737
37738
37739 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37740 PyObject *resultobj = 0;
37741 wxWindow *arg1 = (wxWindow *) 0 ;
37742 wxString result;
37743 void *argp1 = 0 ;
37744 int res1 = 0 ;
37745 PyObject *swig_obj[1] ;
37746
37747 if (!args) SWIG_fail;
37748 swig_obj[0] = args;
37749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37750 if (!SWIG_IsOK(res1)) {
37751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
37752 }
37753 arg1 = reinterpret_cast< wxWindow * >(argp1);
37754 {
37755 PyThreadState* __tstate = wxPyBeginAllowThreads();
37756 result = ((wxWindow const *)arg1)->GetHelpText();
37757 wxPyEndAllowThreads(__tstate);
37758 if (PyErr_Occurred()) SWIG_fail;
37759 }
37760 {
37761 #if wxUSE_UNICODE
37762 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37763 #else
37764 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37765 #endif
37766 }
37767 return resultobj;
37768 fail:
37769 return NULL;
37770 }
37771
37772
37773 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37774 PyObject *resultobj = 0;
37775 wxWindow *arg1 = (wxWindow *) 0 ;
37776 wxString *arg2 = 0 ;
37777 void *argp1 = 0 ;
37778 int res1 = 0 ;
37779 bool temp2 = false ;
37780 PyObject * obj0 = 0 ;
37781 PyObject * obj1 = 0 ;
37782 char * kwnames[] = {
37783 (char *) "self",(char *) "tip", NULL
37784 };
37785
37786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
37787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37788 if (!SWIG_IsOK(res1)) {
37789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
37790 }
37791 arg1 = reinterpret_cast< wxWindow * >(argp1);
37792 {
37793 arg2 = wxString_in_helper(obj1);
37794 if (arg2 == NULL) SWIG_fail;
37795 temp2 = true;
37796 }
37797 {
37798 PyThreadState* __tstate = wxPyBeginAllowThreads();
37799 (arg1)->SetToolTip((wxString const &)*arg2);
37800 wxPyEndAllowThreads(__tstate);
37801 if (PyErr_Occurred()) SWIG_fail;
37802 }
37803 resultobj = SWIG_Py_Void();
37804 {
37805 if (temp2)
37806 delete arg2;
37807 }
37808 return resultobj;
37809 fail:
37810 {
37811 if (temp2)
37812 delete arg2;
37813 }
37814 return NULL;
37815 }
37816
37817
37818 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37819 PyObject *resultobj = 0;
37820 wxWindow *arg1 = (wxWindow *) 0 ;
37821 wxToolTip *arg2 = (wxToolTip *) 0 ;
37822 void *argp1 = 0 ;
37823 int res1 = 0 ;
37824 int res2 = 0 ;
37825 PyObject * obj0 = 0 ;
37826 PyObject * obj1 = 0 ;
37827 char * kwnames[] = {
37828 (char *) "self",(char *) "tip", NULL
37829 };
37830
37831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
37832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37833 if (!SWIG_IsOK(res1)) {
37834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
37835 }
37836 arg1 = reinterpret_cast< wxWindow * >(argp1);
37837 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
37838 if (!SWIG_IsOK(res2)) {
37839 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
37840 }
37841 {
37842 PyThreadState* __tstate = wxPyBeginAllowThreads();
37843 (arg1)->SetToolTip(arg2);
37844 wxPyEndAllowThreads(__tstate);
37845 if (PyErr_Occurred()) SWIG_fail;
37846 }
37847 resultobj = SWIG_Py_Void();
37848 return resultobj;
37849 fail:
37850 return NULL;
37851 }
37852
37853
37854 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37855 PyObject *resultobj = 0;
37856 wxWindow *arg1 = (wxWindow *) 0 ;
37857 wxToolTip *result = 0 ;
37858 void *argp1 = 0 ;
37859 int res1 = 0 ;
37860 PyObject *swig_obj[1] ;
37861
37862 if (!args) SWIG_fail;
37863 swig_obj[0] = args;
37864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37865 if (!SWIG_IsOK(res1)) {
37866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
37867 }
37868 arg1 = reinterpret_cast< wxWindow * >(argp1);
37869 {
37870 PyThreadState* __tstate = wxPyBeginAllowThreads();
37871 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
37872 wxPyEndAllowThreads(__tstate);
37873 if (PyErr_Occurred()) SWIG_fail;
37874 }
37875 {
37876 resultobj = wxPyMake_wxObject(result, (bool)0);
37877 }
37878 return resultobj;
37879 fail:
37880 return NULL;
37881 }
37882
37883
37884 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37885 PyObject *resultobj = 0;
37886 wxWindow *arg1 = (wxWindow *) 0 ;
37887 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
37888 void *argp1 = 0 ;
37889 int res1 = 0 ;
37890 int res2 = 0 ;
37891 PyObject * obj0 = 0 ;
37892 PyObject * obj1 = 0 ;
37893 char * kwnames[] = {
37894 (char *) "self",(char *) "dropTarget", NULL
37895 };
37896
37897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
37898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37899 if (!SWIG_IsOK(res1)) {
37900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
37901 }
37902 arg1 = reinterpret_cast< wxWindow * >(argp1);
37903 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
37904 if (!SWIG_IsOK(res2)) {
37905 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
37906 }
37907 {
37908 PyThreadState* __tstate = wxPyBeginAllowThreads();
37909 (arg1)->SetDropTarget(arg2);
37910 wxPyEndAllowThreads(__tstate);
37911 if (PyErr_Occurred()) SWIG_fail;
37912 }
37913 resultobj = SWIG_Py_Void();
37914 return resultobj;
37915 fail:
37916 return NULL;
37917 }
37918
37919
37920 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37921 PyObject *resultobj = 0;
37922 wxWindow *arg1 = (wxWindow *) 0 ;
37923 wxPyDropTarget *result = 0 ;
37924 void *argp1 = 0 ;
37925 int res1 = 0 ;
37926 PyObject *swig_obj[1] ;
37927
37928 if (!args) SWIG_fail;
37929 swig_obj[0] = args;
37930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37931 if (!SWIG_IsOK(res1)) {
37932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
37933 }
37934 arg1 = reinterpret_cast< wxWindow * >(argp1);
37935 {
37936 PyThreadState* __tstate = wxPyBeginAllowThreads();
37937 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
37938 wxPyEndAllowThreads(__tstate);
37939 if (PyErr_Occurred()) SWIG_fail;
37940 }
37941 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
37942 return resultobj;
37943 fail:
37944 return NULL;
37945 }
37946
37947
37948 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37949 PyObject *resultobj = 0;
37950 wxWindow *arg1 = (wxWindow *) 0 ;
37951 bool arg2 ;
37952 void *argp1 = 0 ;
37953 int res1 = 0 ;
37954 bool val2 ;
37955 int ecode2 = 0 ;
37956 PyObject * obj0 = 0 ;
37957 PyObject * obj1 = 0 ;
37958 char * kwnames[] = {
37959 (char *) "self",(char *) "accept", NULL
37960 };
37961
37962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
37963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37964 if (!SWIG_IsOK(res1)) {
37965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
37966 }
37967 arg1 = reinterpret_cast< wxWindow * >(argp1);
37968 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37969 if (!SWIG_IsOK(ecode2)) {
37970 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
37971 }
37972 arg2 = static_cast< bool >(val2);
37973 {
37974 PyThreadState* __tstate = wxPyBeginAllowThreads();
37975 wxWindow_DragAcceptFiles(arg1,arg2);
37976 wxPyEndAllowThreads(__tstate);
37977 if (PyErr_Occurred()) SWIG_fail;
37978 }
37979 resultobj = SWIG_Py_Void();
37980 return resultobj;
37981 fail:
37982 return NULL;
37983 }
37984
37985
37986 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37987 PyObject *resultobj = 0;
37988 wxWindow *arg1 = (wxWindow *) 0 ;
37989 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
37990 void *argp1 = 0 ;
37991 int res1 = 0 ;
37992 int res2 = 0 ;
37993 PyObject * obj0 = 0 ;
37994 PyObject * obj1 = 0 ;
37995 char * kwnames[] = {
37996 (char *) "self",(char *) "constraints", NULL
37997 };
37998
37999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
38000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38001 if (!SWIG_IsOK(res1)) {
38002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
38003 }
38004 arg1 = reinterpret_cast< wxWindow * >(argp1);
38005 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
38006 if (!SWIG_IsOK(res2)) {
38007 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
38008 }
38009 {
38010 PyThreadState* __tstate = wxPyBeginAllowThreads();
38011 (arg1)->SetConstraints(arg2);
38012 wxPyEndAllowThreads(__tstate);
38013 if (PyErr_Occurred()) SWIG_fail;
38014 }
38015 resultobj = SWIG_Py_Void();
38016 return resultobj;
38017 fail:
38018 return NULL;
38019 }
38020
38021
38022 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38023 PyObject *resultobj = 0;
38024 wxWindow *arg1 = (wxWindow *) 0 ;
38025 wxLayoutConstraints *result = 0 ;
38026 void *argp1 = 0 ;
38027 int res1 = 0 ;
38028 PyObject *swig_obj[1] ;
38029
38030 if (!args) SWIG_fail;
38031 swig_obj[0] = args;
38032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38033 if (!SWIG_IsOK(res1)) {
38034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
38035 }
38036 arg1 = reinterpret_cast< wxWindow * >(argp1);
38037 {
38038 PyThreadState* __tstate = wxPyBeginAllowThreads();
38039 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
38040 wxPyEndAllowThreads(__tstate);
38041 if (PyErr_Occurred()) SWIG_fail;
38042 }
38043 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
38044 return resultobj;
38045 fail:
38046 return NULL;
38047 }
38048
38049
38050 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38051 PyObject *resultobj = 0;
38052 wxWindow *arg1 = (wxWindow *) 0 ;
38053 bool arg2 ;
38054 void *argp1 = 0 ;
38055 int res1 = 0 ;
38056 bool val2 ;
38057 int ecode2 = 0 ;
38058 PyObject * obj0 = 0 ;
38059 PyObject * obj1 = 0 ;
38060 char * kwnames[] = {
38061 (char *) "self",(char *) "autoLayout", NULL
38062 };
38063
38064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
38065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38066 if (!SWIG_IsOK(res1)) {
38067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
38068 }
38069 arg1 = reinterpret_cast< wxWindow * >(argp1);
38070 ecode2 = SWIG_AsVal_bool(obj1, &val2);
38071 if (!SWIG_IsOK(ecode2)) {
38072 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
38073 }
38074 arg2 = static_cast< bool >(val2);
38075 {
38076 PyThreadState* __tstate = wxPyBeginAllowThreads();
38077 (arg1)->SetAutoLayout(arg2);
38078 wxPyEndAllowThreads(__tstate);
38079 if (PyErr_Occurred()) SWIG_fail;
38080 }
38081 resultobj = SWIG_Py_Void();
38082 return resultobj;
38083 fail:
38084 return NULL;
38085 }
38086
38087
38088 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38089 PyObject *resultobj = 0;
38090 wxWindow *arg1 = (wxWindow *) 0 ;
38091 bool result;
38092 void *argp1 = 0 ;
38093 int res1 = 0 ;
38094 PyObject *swig_obj[1] ;
38095
38096 if (!args) SWIG_fail;
38097 swig_obj[0] = args;
38098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38099 if (!SWIG_IsOK(res1)) {
38100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
38101 }
38102 arg1 = reinterpret_cast< wxWindow * >(argp1);
38103 {
38104 PyThreadState* __tstate = wxPyBeginAllowThreads();
38105 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
38106 wxPyEndAllowThreads(__tstate);
38107 if (PyErr_Occurred()) SWIG_fail;
38108 }
38109 {
38110 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38111 }
38112 return resultobj;
38113 fail:
38114 return NULL;
38115 }
38116
38117
38118 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38119 PyObject *resultobj = 0;
38120 wxWindow *arg1 = (wxWindow *) 0 ;
38121 bool result;
38122 void *argp1 = 0 ;
38123 int res1 = 0 ;
38124 PyObject *swig_obj[1] ;
38125
38126 if (!args) SWIG_fail;
38127 swig_obj[0] = args;
38128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38129 if (!SWIG_IsOK(res1)) {
38130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
38131 }
38132 arg1 = reinterpret_cast< wxWindow * >(argp1);
38133 {
38134 PyThreadState* __tstate = wxPyBeginAllowThreads();
38135 result = (bool)(arg1)->Layout();
38136 wxPyEndAllowThreads(__tstate);
38137 if (PyErr_Occurred()) SWIG_fail;
38138 }
38139 {
38140 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38141 }
38142 return resultobj;
38143 fail:
38144 return NULL;
38145 }
38146
38147
38148 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38149 PyObject *resultobj = 0;
38150 wxWindow *arg1 = (wxWindow *) 0 ;
38151 wxSizer *arg2 = (wxSizer *) 0 ;
38152 bool arg3 = (bool) true ;
38153 void *argp1 = 0 ;
38154 int res1 = 0 ;
38155 int res2 = 0 ;
38156 bool val3 ;
38157 int ecode3 = 0 ;
38158 PyObject * obj0 = 0 ;
38159 PyObject * obj1 = 0 ;
38160 PyObject * obj2 = 0 ;
38161 char * kwnames[] = {
38162 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
38163 };
38164
38165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38167 if (!SWIG_IsOK(res1)) {
38168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
38169 }
38170 arg1 = reinterpret_cast< wxWindow * >(argp1);
38171 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
38172 if (!SWIG_IsOK(res2)) {
38173 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
38174 }
38175 if (obj2) {
38176 ecode3 = SWIG_AsVal_bool(obj2, &val3);
38177 if (!SWIG_IsOK(ecode3)) {
38178 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
38179 }
38180 arg3 = static_cast< bool >(val3);
38181 }
38182 {
38183 PyThreadState* __tstate = wxPyBeginAllowThreads();
38184 (arg1)->SetSizer(arg2,arg3);
38185 wxPyEndAllowThreads(__tstate);
38186 if (PyErr_Occurred()) SWIG_fail;
38187 }
38188 resultobj = SWIG_Py_Void();
38189 return resultobj;
38190 fail:
38191 return NULL;
38192 }
38193
38194
38195 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38196 PyObject *resultobj = 0;
38197 wxWindow *arg1 = (wxWindow *) 0 ;
38198 wxSizer *arg2 = (wxSizer *) 0 ;
38199 bool arg3 = (bool) true ;
38200 void *argp1 = 0 ;
38201 int res1 = 0 ;
38202 int res2 = 0 ;
38203 bool val3 ;
38204 int ecode3 = 0 ;
38205 PyObject * obj0 = 0 ;
38206 PyObject * obj1 = 0 ;
38207 PyObject * obj2 = 0 ;
38208 char * kwnames[] = {
38209 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
38210 };
38211
38212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38214 if (!SWIG_IsOK(res1)) {
38215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
38216 }
38217 arg1 = reinterpret_cast< wxWindow * >(argp1);
38218 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
38219 if (!SWIG_IsOK(res2)) {
38220 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
38221 }
38222 if (obj2) {
38223 ecode3 = SWIG_AsVal_bool(obj2, &val3);
38224 if (!SWIG_IsOK(ecode3)) {
38225 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
38226 }
38227 arg3 = static_cast< bool >(val3);
38228 }
38229 {
38230 PyThreadState* __tstate = wxPyBeginAllowThreads();
38231 (arg1)->SetSizerAndFit(arg2,arg3);
38232 wxPyEndAllowThreads(__tstate);
38233 if (PyErr_Occurred()) SWIG_fail;
38234 }
38235 resultobj = SWIG_Py_Void();
38236 return resultobj;
38237 fail:
38238 return NULL;
38239 }
38240
38241
38242 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38243 PyObject *resultobj = 0;
38244 wxWindow *arg1 = (wxWindow *) 0 ;
38245 wxSizer *result = 0 ;
38246 void *argp1 = 0 ;
38247 int res1 = 0 ;
38248 PyObject *swig_obj[1] ;
38249
38250 if (!args) SWIG_fail;
38251 swig_obj[0] = args;
38252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38253 if (!SWIG_IsOK(res1)) {
38254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
38255 }
38256 arg1 = reinterpret_cast< wxWindow * >(argp1);
38257 {
38258 PyThreadState* __tstate = wxPyBeginAllowThreads();
38259 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
38260 wxPyEndAllowThreads(__tstate);
38261 if (PyErr_Occurred()) SWIG_fail;
38262 }
38263 {
38264 resultobj = wxPyMake_wxObject(result, (bool)0);
38265 }
38266 return resultobj;
38267 fail:
38268 return NULL;
38269 }
38270
38271
38272 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38273 PyObject *resultobj = 0;
38274 wxWindow *arg1 = (wxWindow *) 0 ;
38275 wxSizer *arg2 = (wxSizer *) 0 ;
38276 void *argp1 = 0 ;
38277 int res1 = 0 ;
38278 void *argp2 = 0 ;
38279 int res2 = 0 ;
38280 PyObject * obj0 = 0 ;
38281 PyObject * obj1 = 0 ;
38282 char * kwnames[] = {
38283 (char *) "self",(char *) "sizer", NULL
38284 };
38285
38286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
38287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38288 if (!SWIG_IsOK(res1)) {
38289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
38290 }
38291 arg1 = reinterpret_cast< wxWindow * >(argp1);
38292 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
38293 if (!SWIG_IsOK(res2)) {
38294 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
38295 }
38296 arg2 = reinterpret_cast< wxSizer * >(argp2);
38297 {
38298 PyThreadState* __tstate = wxPyBeginAllowThreads();
38299 (arg1)->SetContainingSizer(arg2);
38300 wxPyEndAllowThreads(__tstate);
38301 if (PyErr_Occurred()) SWIG_fail;
38302 }
38303 resultobj = SWIG_Py_Void();
38304 return resultobj;
38305 fail:
38306 return NULL;
38307 }
38308
38309
38310 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38311 PyObject *resultobj = 0;
38312 wxWindow *arg1 = (wxWindow *) 0 ;
38313 wxSizer *result = 0 ;
38314 void *argp1 = 0 ;
38315 int res1 = 0 ;
38316 PyObject *swig_obj[1] ;
38317
38318 if (!args) SWIG_fail;
38319 swig_obj[0] = args;
38320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38321 if (!SWIG_IsOK(res1)) {
38322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
38323 }
38324 arg1 = reinterpret_cast< wxWindow * >(argp1);
38325 {
38326 PyThreadState* __tstate = wxPyBeginAllowThreads();
38327 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
38328 wxPyEndAllowThreads(__tstate);
38329 if (PyErr_Occurred()) SWIG_fail;
38330 }
38331 {
38332 resultobj = wxPyMake_wxObject(result, (bool)0);
38333 }
38334 return resultobj;
38335 fail:
38336 return NULL;
38337 }
38338
38339
38340 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38341 PyObject *resultobj = 0;
38342 wxWindow *arg1 = (wxWindow *) 0 ;
38343 void *argp1 = 0 ;
38344 int res1 = 0 ;
38345 PyObject *swig_obj[1] ;
38346
38347 if (!args) SWIG_fail;
38348 swig_obj[0] = args;
38349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38350 if (!SWIG_IsOK(res1)) {
38351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
38352 }
38353 arg1 = reinterpret_cast< wxWindow * >(argp1);
38354 {
38355 PyThreadState* __tstate = wxPyBeginAllowThreads();
38356 (arg1)->InheritAttributes();
38357 wxPyEndAllowThreads(__tstate);
38358 if (PyErr_Occurred()) SWIG_fail;
38359 }
38360 resultobj = SWIG_Py_Void();
38361 return resultobj;
38362 fail:
38363 return NULL;
38364 }
38365
38366
38367 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38368 PyObject *resultobj = 0;
38369 wxWindow *arg1 = (wxWindow *) 0 ;
38370 bool result;
38371 void *argp1 = 0 ;
38372 int res1 = 0 ;
38373 PyObject *swig_obj[1] ;
38374
38375 if (!args) SWIG_fail;
38376 swig_obj[0] = args;
38377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38378 if (!SWIG_IsOK(res1)) {
38379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
38380 }
38381 arg1 = reinterpret_cast< wxWindow * >(argp1);
38382 {
38383 PyThreadState* __tstate = wxPyBeginAllowThreads();
38384 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
38385 wxPyEndAllowThreads(__tstate);
38386 if (PyErr_Occurred()) SWIG_fail;
38387 }
38388 {
38389 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38390 }
38391 return resultobj;
38392 fail:
38393 return NULL;
38394 }
38395
38396
38397 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38398 PyObject *resultobj = 0;
38399 wxWindow *arg1 = (wxWindow *) 0 ;
38400 bool result;
38401 void *argp1 = 0 ;
38402 int res1 = 0 ;
38403 PyObject *swig_obj[1] ;
38404
38405 if (!args) SWIG_fail;
38406 swig_obj[0] = args;
38407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38408 if (!SWIG_IsOK(res1)) {
38409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
38410 }
38411 arg1 = reinterpret_cast< wxWindow * >(argp1);
38412 {
38413 PyThreadState* __tstate = wxPyBeginAllowThreads();
38414 result = (bool)(arg1)->CanSetTransparent();
38415 wxPyEndAllowThreads(__tstate);
38416 if (PyErr_Occurred()) SWIG_fail;
38417 }
38418 {
38419 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38420 }
38421 return resultobj;
38422 fail:
38423 return NULL;
38424 }
38425
38426
38427 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38428 PyObject *resultobj = 0;
38429 wxWindow *arg1 = (wxWindow *) 0 ;
38430 byte arg2 ;
38431 bool result;
38432 void *argp1 = 0 ;
38433 int res1 = 0 ;
38434 unsigned char val2 ;
38435 int ecode2 = 0 ;
38436 PyObject * obj0 = 0 ;
38437 PyObject * obj1 = 0 ;
38438 char * kwnames[] = {
38439 (char *) "self",(char *) "alpha", NULL
38440 };
38441
38442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
38443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38444 if (!SWIG_IsOK(res1)) {
38445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
38446 }
38447 arg1 = reinterpret_cast< wxWindow * >(argp1);
38448 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
38449 if (!SWIG_IsOK(ecode2)) {
38450 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
38451 }
38452 arg2 = static_cast< byte >(val2);
38453 {
38454 PyThreadState* __tstate = wxPyBeginAllowThreads();
38455 result = (bool)(arg1)->SetTransparent(arg2);
38456 wxPyEndAllowThreads(__tstate);
38457 if (PyErr_Occurred()) SWIG_fail;
38458 }
38459 {
38460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38461 }
38462 return resultobj;
38463 fail:
38464 return NULL;
38465 }
38466
38467
38468 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38469 PyObject *obj;
38470 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38471 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
38472 return SWIG_Py_Void();
38473 }
38474
38475 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38476 return SWIG_Python_InitShadowInstance(args);
38477 }
38478
38479 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38480 PyObject *resultobj = 0;
38481 long arg1 ;
38482 wxWindow *arg2 = (wxWindow *) NULL ;
38483 wxWindow *result = 0 ;
38484 long val1 ;
38485 int ecode1 = 0 ;
38486 void *argp2 = 0 ;
38487 int res2 = 0 ;
38488 PyObject * obj0 = 0 ;
38489 PyObject * obj1 = 0 ;
38490 char * kwnames[] = {
38491 (char *) "id",(char *) "parent", NULL
38492 };
38493
38494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
38495 ecode1 = SWIG_AsVal_long(obj0, &val1);
38496 if (!SWIG_IsOK(ecode1)) {
38497 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
38498 }
38499 arg1 = static_cast< long >(val1);
38500 if (obj1) {
38501 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38502 if (!SWIG_IsOK(res2)) {
38503 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
38504 }
38505 arg2 = reinterpret_cast< wxWindow * >(argp2);
38506 }
38507 {
38508 if (!wxPyCheckForApp()) SWIG_fail;
38509 PyThreadState* __tstate = wxPyBeginAllowThreads();
38510 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
38511 wxPyEndAllowThreads(__tstate);
38512 if (PyErr_Occurred()) SWIG_fail;
38513 }
38514 {
38515 resultobj = wxPyMake_wxObject(result, 0);
38516 }
38517 return resultobj;
38518 fail:
38519 return NULL;
38520 }
38521
38522
38523 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38524 PyObject *resultobj = 0;
38525 wxString *arg1 = 0 ;
38526 wxWindow *arg2 = (wxWindow *) NULL ;
38527 wxWindow *result = 0 ;
38528 bool temp1 = false ;
38529 void *argp2 = 0 ;
38530 int res2 = 0 ;
38531 PyObject * obj0 = 0 ;
38532 PyObject * obj1 = 0 ;
38533 char * kwnames[] = {
38534 (char *) "name",(char *) "parent", NULL
38535 };
38536
38537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
38538 {
38539 arg1 = wxString_in_helper(obj0);
38540 if (arg1 == NULL) SWIG_fail;
38541 temp1 = true;
38542 }
38543 if (obj1) {
38544 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38545 if (!SWIG_IsOK(res2)) {
38546 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
38547 }
38548 arg2 = reinterpret_cast< wxWindow * >(argp2);
38549 }
38550 {
38551 if (!wxPyCheckForApp()) SWIG_fail;
38552 PyThreadState* __tstate = wxPyBeginAllowThreads();
38553 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
38554 wxPyEndAllowThreads(__tstate);
38555 if (PyErr_Occurred()) SWIG_fail;
38556 }
38557 {
38558 resultobj = wxPyMake_wxObject(result, 0);
38559 }
38560 {
38561 if (temp1)
38562 delete arg1;
38563 }
38564 return resultobj;
38565 fail:
38566 {
38567 if (temp1)
38568 delete arg1;
38569 }
38570 return NULL;
38571 }
38572
38573
38574 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38575 PyObject *resultobj = 0;
38576 wxString *arg1 = 0 ;
38577 wxWindow *arg2 = (wxWindow *) NULL ;
38578 wxWindow *result = 0 ;
38579 bool temp1 = false ;
38580 void *argp2 = 0 ;
38581 int res2 = 0 ;
38582 PyObject * obj0 = 0 ;
38583 PyObject * obj1 = 0 ;
38584 char * kwnames[] = {
38585 (char *) "label",(char *) "parent", NULL
38586 };
38587
38588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
38589 {
38590 arg1 = wxString_in_helper(obj0);
38591 if (arg1 == NULL) SWIG_fail;
38592 temp1 = true;
38593 }
38594 if (obj1) {
38595 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38596 if (!SWIG_IsOK(res2)) {
38597 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
38598 }
38599 arg2 = reinterpret_cast< wxWindow * >(argp2);
38600 }
38601 {
38602 if (!wxPyCheckForApp()) SWIG_fail;
38603 PyThreadState* __tstate = wxPyBeginAllowThreads();
38604 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
38605 wxPyEndAllowThreads(__tstate);
38606 if (PyErr_Occurred()) SWIG_fail;
38607 }
38608 {
38609 resultobj = wxPyMake_wxObject(result, 0);
38610 }
38611 {
38612 if (temp1)
38613 delete arg1;
38614 }
38615 return resultobj;
38616 fail:
38617 {
38618 if (temp1)
38619 delete arg1;
38620 }
38621 return NULL;
38622 }
38623
38624
38625 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38626 PyObject *resultobj = 0;
38627 wxWindow *arg1 = (wxWindow *) 0 ;
38628 unsigned long arg2 ;
38629 wxWindow *result = 0 ;
38630 void *argp1 = 0 ;
38631 int res1 = 0 ;
38632 unsigned long val2 ;
38633 int ecode2 = 0 ;
38634 PyObject * obj0 = 0 ;
38635 PyObject * obj1 = 0 ;
38636 char * kwnames[] = {
38637 (char *) "parent",(char *) "_hWnd", NULL
38638 };
38639
38640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
38641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38642 if (!SWIG_IsOK(res1)) {
38643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
38644 }
38645 arg1 = reinterpret_cast< wxWindow * >(argp1);
38646 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
38647 if (!SWIG_IsOK(ecode2)) {
38648 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
38649 }
38650 arg2 = static_cast< unsigned long >(val2);
38651 {
38652 PyThreadState* __tstate = wxPyBeginAllowThreads();
38653 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
38654 wxPyEndAllowThreads(__tstate);
38655 if (PyErr_Occurred()) SWIG_fail;
38656 }
38657 {
38658 resultobj = wxPyMake_wxObject(result, 0);
38659 }
38660 return resultobj;
38661 fail:
38662 return NULL;
38663 }
38664
38665
38666 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38667 PyObject *resultobj = 0;
38668 PyObject *result = 0 ;
38669
38670 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
38671 {
38672 PyThreadState* __tstate = wxPyBeginAllowThreads();
38673 result = (PyObject *)GetTopLevelWindows();
38674 wxPyEndAllowThreads(__tstate);
38675 if (PyErr_Occurred()) SWIG_fail;
38676 }
38677 resultobj = result;
38678 return resultobj;
38679 fail:
38680 return NULL;
38681 }
38682
38683
38684 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38685 PyObject *resultobj = 0;
38686 wxValidator *result = 0 ;
38687
38688 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
38689 {
38690 PyThreadState* __tstate = wxPyBeginAllowThreads();
38691 result = (wxValidator *)new wxValidator();
38692 wxPyEndAllowThreads(__tstate);
38693 if (PyErr_Occurred()) SWIG_fail;
38694 }
38695 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
38696 return resultobj;
38697 fail:
38698 return NULL;
38699 }
38700
38701
38702 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38703 PyObject *resultobj = 0;
38704 wxValidator *arg1 = (wxValidator *) 0 ;
38705 wxValidator *result = 0 ;
38706 void *argp1 = 0 ;
38707 int res1 = 0 ;
38708 PyObject *swig_obj[1] ;
38709
38710 if (!args) SWIG_fail;
38711 swig_obj[0] = args;
38712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38713 if (!SWIG_IsOK(res1)) {
38714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
38715 }
38716 arg1 = reinterpret_cast< wxValidator * >(argp1);
38717 {
38718 PyThreadState* __tstate = wxPyBeginAllowThreads();
38719 result = (wxValidator *)(arg1)->Clone();
38720 wxPyEndAllowThreads(__tstate);
38721 if (PyErr_Occurred()) SWIG_fail;
38722 }
38723 {
38724 resultobj = wxPyMake_wxObject(result, 0);
38725 }
38726 return resultobj;
38727 fail:
38728 return NULL;
38729 }
38730
38731
38732 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38733 PyObject *resultobj = 0;
38734 wxValidator *arg1 = (wxValidator *) 0 ;
38735 wxWindow *arg2 = (wxWindow *) 0 ;
38736 bool result;
38737 void *argp1 = 0 ;
38738 int res1 = 0 ;
38739 void *argp2 = 0 ;
38740 int res2 = 0 ;
38741 PyObject * obj0 = 0 ;
38742 PyObject * obj1 = 0 ;
38743 char * kwnames[] = {
38744 (char *) "self",(char *) "parent", NULL
38745 };
38746
38747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
38748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38749 if (!SWIG_IsOK(res1)) {
38750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
38751 }
38752 arg1 = reinterpret_cast< wxValidator * >(argp1);
38753 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38754 if (!SWIG_IsOK(res2)) {
38755 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
38756 }
38757 arg2 = reinterpret_cast< wxWindow * >(argp2);
38758 {
38759 PyThreadState* __tstate = wxPyBeginAllowThreads();
38760 result = (bool)(arg1)->Validate(arg2);
38761 wxPyEndAllowThreads(__tstate);
38762 if (PyErr_Occurred()) SWIG_fail;
38763 }
38764 {
38765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38766 }
38767 return resultobj;
38768 fail:
38769 return NULL;
38770 }
38771
38772
38773 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38774 PyObject *resultobj = 0;
38775 wxValidator *arg1 = (wxValidator *) 0 ;
38776 bool result;
38777 void *argp1 = 0 ;
38778 int res1 = 0 ;
38779 PyObject *swig_obj[1] ;
38780
38781 if (!args) SWIG_fail;
38782 swig_obj[0] = args;
38783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38784 if (!SWIG_IsOK(res1)) {
38785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38786 }
38787 arg1 = reinterpret_cast< wxValidator * >(argp1);
38788 {
38789 PyThreadState* __tstate = wxPyBeginAllowThreads();
38790 result = (bool)(arg1)->TransferToWindow();
38791 wxPyEndAllowThreads(__tstate);
38792 if (PyErr_Occurred()) SWIG_fail;
38793 }
38794 {
38795 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38796 }
38797 return resultobj;
38798 fail:
38799 return NULL;
38800 }
38801
38802
38803 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38804 PyObject *resultobj = 0;
38805 wxValidator *arg1 = (wxValidator *) 0 ;
38806 bool result;
38807 void *argp1 = 0 ;
38808 int res1 = 0 ;
38809 PyObject *swig_obj[1] ;
38810
38811 if (!args) SWIG_fail;
38812 swig_obj[0] = args;
38813 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38814 if (!SWIG_IsOK(res1)) {
38815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38816 }
38817 arg1 = reinterpret_cast< wxValidator * >(argp1);
38818 {
38819 PyThreadState* __tstate = wxPyBeginAllowThreads();
38820 result = (bool)(arg1)->TransferFromWindow();
38821 wxPyEndAllowThreads(__tstate);
38822 if (PyErr_Occurred()) SWIG_fail;
38823 }
38824 {
38825 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38826 }
38827 return resultobj;
38828 fail:
38829 return NULL;
38830 }
38831
38832
38833 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38834 PyObject *resultobj = 0;
38835 wxValidator *arg1 = (wxValidator *) 0 ;
38836 wxWindow *result = 0 ;
38837 void *argp1 = 0 ;
38838 int res1 = 0 ;
38839 PyObject *swig_obj[1] ;
38840
38841 if (!args) SWIG_fail;
38842 swig_obj[0] = args;
38843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38844 if (!SWIG_IsOK(res1)) {
38845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38846 }
38847 arg1 = reinterpret_cast< wxValidator * >(argp1);
38848 {
38849 PyThreadState* __tstate = wxPyBeginAllowThreads();
38850 result = (wxWindow *)(arg1)->GetWindow();
38851 wxPyEndAllowThreads(__tstate);
38852 if (PyErr_Occurred()) SWIG_fail;
38853 }
38854 {
38855 resultobj = wxPyMake_wxObject(result, 0);
38856 }
38857 return resultobj;
38858 fail:
38859 return NULL;
38860 }
38861
38862
38863 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38864 PyObject *resultobj = 0;
38865 wxValidator *arg1 = (wxValidator *) 0 ;
38866 wxWindow *arg2 = (wxWindow *) 0 ;
38867 void *argp1 = 0 ;
38868 int res1 = 0 ;
38869 void *argp2 = 0 ;
38870 int res2 = 0 ;
38871 PyObject * obj0 = 0 ;
38872 PyObject * obj1 = 0 ;
38873 char * kwnames[] = {
38874 (char *) "self",(char *) "window", NULL
38875 };
38876
38877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
38878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38879 if (!SWIG_IsOK(res1)) {
38880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38881 }
38882 arg1 = reinterpret_cast< wxValidator * >(argp1);
38883 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38884 if (!SWIG_IsOK(res2)) {
38885 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
38886 }
38887 arg2 = reinterpret_cast< wxWindow * >(argp2);
38888 {
38889 PyThreadState* __tstate = wxPyBeginAllowThreads();
38890 (arg1)->SetWindow(arg2);
38891 wxPyEndAllowThreads(__tstate);
38892 if (PyErr_Occurred()) SWIG_fail;
38893 }
38894 resultobj = SWIG_Py_Void();
38895 return resultobj;
38896 fail:
38897 return NULL;
38898 }
38899
38900
38901 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38902 PyObject *resultobj = 0;
38903 bool result;
38904
38905 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
38906 {
38907 PyThreadState* __tstate = wxPyBeginAllowThreads();
38908 result = (bool)wxValidator::IsSilent();
38909 wxPyEndAllowThreads(__tstate);
38910 if (PyErr_Occurred()) SWIG_fail;
38911 }
38912 {
38913 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38914 }
38915 return resultobj;
38916 fail:
38917 return NULL;
38918 }
38919
38920
38921 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38922 PyObject *resultobj = 0;
38923 int arg1 = (int) true ;
38924 int val1 ;
38925 int ecode1 = 0 ;
38926 PyObject * obj0 = 0 ;
38927 char * kwnames[] = {
38928 (char *) "doIt", NULL
38929 };
38930
38931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
38932 if (obj0) {
38933 ecode1 = SWIG_AsVal_int(obj0, &val1);
38934 if (!SWIG_IsOK(ecode1)) {
38935 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
38936 }
38937 arg1 = static_cast< int >(val1);
38938 }
38939 {
38940 PyThreadState* __tstate = wxPyBeginAllowThreads();
38941 wxValidator::SetBellOnError(arg1);
38942 wxPyEndAllowThreads(__tstate);
38943 if (PyErr_Occurred()) SWIG_fail;
38944 }
38945 resultobj = SWIG_Py_Void();
38946 return resultobj;
38947 fail:
38948 return NULL;
38949 }
38950
38951
38952 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38953 PyObject *obj;
38954 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38955 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
38956 return SWIG_Py_Void();
38957 }
38958
38959 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38960 return SWIG_Python_InitShadowInstance(args);
38961 }
38962
38963 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38964 PyObject *resultobj = 0;
38965 wxPyValidator *result = 0 ;
38966
38967 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
38968 {
38969 PyThreadState* __tstate = wxPyBeginAllowThreads();
38970 result = (wxPyValidator *)new wxPyValidator();
38971 wxPyEndAllowThreads(__tstate);
38972 if (PyErr_Occurred()) SWIG_fail;
38973 }
38974 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
38975 return resultobj;
38976 fail:
38977 return NULL;
38978 }
38979
38980
38981 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38982 PyObject *resultobj = 0;
38983 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
38984 PyObject *arg2 = (PyObject *) 0 ;
38985 PyObject *arg3 = (PyObject *) 0 ;
38986 int arg4 = (int) true ;
38987 void *argp1 = 0 ;
38988 int res1 = 0 ;
38989 int val4 ;
38990 int ecode4 = 0 ;
38991 PyObject * obj0 = 0 ;
38992 PyObject * obj1 = 0 ;
38993 PyObject * obj2 = 0 ;
38994 PyObject * obj3 = 0 ;
38995 char * kwnames[] = {
38996 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
38997 };
38998
38999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
39001 if (!SWIG_IsOK(res1)) {
39002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
39003 }
39004 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
39005 arg2 = obj1;
39006 arg3 = obj2;
39007 if (obj3) {
39008 ecode4 = SWIG_AsVal_int(obj3, &val4);
39009 if (!SWIG_IsOK(ecode4)) {
39010 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
39011 }
39012 arg4 = static_cast< int >(val4);
39013 }
39014 {
39015 PyThreadState* __tstate = wxPyBeginAllowThreads();
39016 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
39017 wxPyEndAllowThreads(__tstate);
39018 if (PyErr_Occurred()) SWIG_fail;
39019 }
39020 resultobj = SWIG_Py_Void();
39021 return resultobj;
39022 fail:
39023 return NULL;
39024 }
39025
39026
39027 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39028 PyObject *obj;
39029 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
39030 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
39031 return SWIG_Py_Void();
39032 }
39033
39034 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39035 return SWIG_Python_InitShadowInstance(args);
39036 }
39037
39038 SWIGINTERN int DefaultValidator_set(PyObject *) {
39039 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
39040 return 1;
39041 }
39042
39043
39044 SWIGINTERN PyObject *DefaultValidator_get(void) {
39045 PyObject *pyobj = 0;
39046
39047 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
39048 return pyobj;
39049 }
39050
39051
39052 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39053 PyObject *resultobj = 0;
39054 wxString const &arg1_defvalue = wxPyEmptyString ;
39055 wxString *arg1 = (wxString *) &arg1_defvalue ;
39056 long arg2 = (long) 0 ;
39057 wxMenu *result = 0 ;
39058 bool temp1 = false ;
39059 long val2 ;
39060 int ecode2 = 0 ;
39061 PyObject * obj0 = 0 ;
39062 PyObject * obj1 = 0 ;
39063 char * kwnames[] = {
39064 (char *) "title",(char *) "style", NULL
39065 };
39066
39067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
39068 if (obj0) {
39069 {
39070 arg1 = wxString_in_helper(obj0);
39071 if (arg1 == NULL) SWIG_fail;
39072 temp1 = true;
39073 }
39074 }
39075 if (obj1) {
39076 ecode2 = SWIG_AsVal_long(obj1, &val2);
39077 if (!SWIG_IsOK(ecode2)) {
39078 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
39079 }
39080 arg2 = static_cast< long >(val2);
39081 }
39082 {
39083 if (!wxPyCheckForApp()) SWIG_fail;
39084 PyThreadState* __tstate = wxPyBeginAllowThreads();
39085 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
39086 wxPyEndAllowThreads(__tstate);
39087 if (PyErr_Occurred()) SWIG_fail;
39088 }
39089 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
39090 {
39091 if (temp1)
39092 delete arg1;
39093 }
39094 return resultobj;
39095 fail:
39096 {
39097 if (temp1)
39098 delete arg1;
39099 }
39100 return NULL;
39101 }
39102
39103
39104 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39105 PyObject *resultobj = 0;
39106 wxMenu *arg1 = (wxMenu *) 0 ;
39107 int arg2 ;
39108 wxString const &arg3_defvalue = wxPyEmptyString ;
39109 wxString *arg3 = (wxString *) &arg3_defvalue ;
39110 wxString const &arg4_defvalue = wxPyEmptyString ;
39111 wxString *arg4 = (wxString *) &arg4_defvalue ;
39112 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39113 wxMenuItem *result = 0 ;
39114 void *argp1 = 0 ;
39115 int res1 = 0 ;
39116 int val2 ;
39117 int ecode2 = 0 ;
39118 bool temp3 = false ;
39119 bool temp4 = false ;
39120 int val5 ;
39121 int ecode5 = 0 ;
39122 PyObject * obj0 = 0 ;
39123 PyObject * obj1 = 0 ;
39124 PyObject * obj2 = 0 ;
39125 PyObject * obj3 = 0 ;
39126 PyObject * obj4 = 0 ;
39127 char * kwnames[] = {
39128 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39129 };
39130
39131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39133 if (!SWIG_IsOK(res1)) {
39134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
39135 }
39136 arg1 = reinterpret_cast< wxMenu * >(argp1);
39137 ecode2 = SWIG_AsVal_int(obj1, &val2);
39138 if (!SWIG_IsOK(ecode2)) {
39139 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
39140 }
39141 arg2 = static_cast< int >(val2);
39142 if (obj2) {
39143 {
39144 arg3 = wxString_in_helper(obj2);
39145 if (arg3 == NULL) SWIG_fail;
39146 temp3 = true;
39147 }
39148 }
39149 if (obj3) {
39150 {
39151 arg4 = wxString_in_helper(obj3);
39152 if (arg4 == NULL) SWIG_fail;
39153 temp4 = true;
39154 }
39155 }
39156 if (obj4) {
39157 ecode5 = SWIG_AsVal_int(obj4, &val5);
39158 if (!SWIG_IsOK(ecode5)) {
39159 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
39160 }
39161 arg5 = static_cast< wxItemKind >(val5);
39162 }
39163 {
39164 PyThreadState* __tstate = wxPyBeginAllowThreads();
39165 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39166 wxPyEndAllowThreads(__tstate);
39167 if (PyErr_Occurred()) SWIG_fail;
39168 }
39169 {
39170 resultobj = wxPyMake_wxObject(result, (bool)0);
39171 }
39172 {
39173 if (temp3)
39174 delete arg3;
39175 }
39176 {
39177 if (temp4)
39178 delete arg4;
39179 }
39180 return resultobj;
39181 fail:
39182 {
39183 if (temp3)
39184 delete arg3;
39185 }
39186 {
39187 if (temp4)
39188 delete arg4;
39189 }
39190 return NULL;
39191 }
39192
39193
39194 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39195 PyObject *resultobj = 0;
39196 wxMenu *arg1 = (wxMenu *) 0 ;
39197 wxMenuItem *result = 0 ;
39198 void *argp1 = 0 ;
39199 int res1 = 0 ;
39200 PyObject *swig_obj[1] ;
39201
39202 if (!args) SWIG_fail;
39203 swig_obj[0] = args;
39204 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39205 if (!SWIG_IsOK(res1)) {
39206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39207 }
39208 arg1 = reinterpret_cast< wxMenu * >(argp1);
39209 {
39210 PyThreadState* __tstate = wxPyBeginAllowThreads();
39211 result = (wxMenuItem *)(arg1)->AppendSeparator();
39212 wxPyEndAllowThreads(__tstate);
39213 if (PyErr_Occurred()) SWIG_fail;
39214 }
39215 {
39216 resultobj = wxPyMake_wxObject(result, (bool)0);
39217 }
39218 return resultobj;
39219 fail:
39220 return NULL;
39221 }
39222
39223
39224 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39225 PyObject *resultobj = 0;
39226 wxMenu *arg1 = (wxMenu *) 0 ;
39227 int arg2 ;
39228 wxString *arg3 = 0 ;
39229 wxString const &arg4_defvalue = wxPyEmptyString ;
39230 wxString *arg4 = (wxString *) &arg4_defvalue ;
39231 wxMenuItem *result = 0 ;
39232 void *argp1 = 0 ;
39233 int res1 = 0 ;
39234 int val2 ;
39235 int ecode2 = 0 ;
39236 bool temp3 = false ;
39237 bool temp4 = false ;
39238 PyObject * obj0 = 0 ;
39239 PyObject * obj1 = 0 ;
39240 PyObject * obj2 = 0 ;
39241 PyObject * obj3 = 0 ;
39242 char * kwnames[] = {
39243 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39244 };
39245
39246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39248 if (!SWIG_IsOK(res1)) {
39249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39250 }
39251 arg1 = reinterpret_cast< wxMenu * >(argp1);
39252 ecode2 = SWIG_AsVal_int(obj1, &val2);
39253 if (!SWIG_IsOK(ecode2)) {
39254 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
39255 }
39256 arg2 = static_cast< int >(val2);
39257 {
39258 arg3 = wxString_in_helper(obj2);
39259 if (arg3 == NULL) SWIG_fail;
39260 temp3 = true;
39261 }
39262 if (obj3) {
39263 {
39264 arg4 = wxString_in_helper(obj3);
39265 if (arg4 == NULL) SWIG_fail;
39266 temp4 = true;
39267 }
39268 }
39269 {
39270 PyThreadState* __tstate = wxPyBeginAllowThreads();
39271 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39272 wxPyEndAllowThreads(__tstate);
39273 if (PyErr_Occurred()) SWIG_fail;
39274 }
39275 {
39276 resultobj = wxPyMake_wxObject(result, (bool)0);
39277 }
39278 {
39279 if (temp3)
39280 delete arg3;
39281 }
39282 {
39283 if (temp4)
39284 delete arg4;
39285 }
39286 return resultobj;
39287 fail:
39288 {
39289 if (temp3)
39290 delete arg3;
39291 }
39292 {
39293 if (temp4)
39294 delete arg4;
39295 }
39296 return NULL;
39297 }
39298
39299
39300 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39301 PyObject *resultobj = 0;
39302 wxMenu *arg1 = (wxMenu *) 0 ;
39303 int arg2 ;
39304 wxString *arg3 = 0 ;
39305 wxString const &arg4_defvalue = wxPyEmptyString ;
39306 wxString *arg4 = (wxString *) &arg4_defvalue ;
39307 wxMenuItem *result = 0 ;
39308 void *argp1 = 0 ;
39309 int res1 = 0 ;
39310 int val2 ;
39311 int ecode2 = 0 ;
39312 bool temp3 = false ;
39313 bool temp4 = false ;
39314 PyObject * obj0 = 0 ;
39315 PyObject * obj1 = 0 ;
39316 PyObject * obj2 = 0 ;
39317 PyObject * obj3 = 0 ;
39318 char * kwnames[] = {
39319 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39320 };
39321
39322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39324 if (!SWIG_IsOK(res1)) {
39325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39326 }
39327 arg1 = reinterpret_cast< wxMenu * >(argp1);
39328 ecode2 = SWIG_AsVal_int(obj1, &val2);
39329 if (!SWIG_IsOK(ecode2)) {
39330 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
39331 }
39332 arg2 = static_cast< int >(val2);
39333 {
39334 arg3 = wxString_in_helper(obj2);
39335 if (arg3 == NULL) SWIG_fail;
39336 temp3 = true;
39337 }
39338 if (obj3) {
39339 {
39340 arg4 = wxString_in_helper(obj3);
39341 if (arg4 == NULL) SWIG_fail;
39342 temp4 = true;
39343 }
39344 }
39345 {
39346 PyThreadState* __tstate = wxPyBeginAllowThreads();
39347 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39348 wxPyEndAllowThreads(__tstate);
39349 if (PyErr_Occurred()) SWIG_fail;
39350 }
39351 {
39352 resultobj = wxPyMake_wxObject(result, (bool)0);
39353 }
39354 {
39355 if (temp3)
39356 delete arg3;
39357 }
39358 {
39359 if (temp4)
39360 delete arg4;
39361 }
39362 return resultobj;
39363 fail:
39364 {
39365 if (temp3)
39366 delete arg3;
39367 }
39368 {
39369 if (temp4)
39370 delete arg4;
39371 }
39372 return NULL;
39373 }
39374
39375
39376 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39377 PyObject *resultobj = 0;
39378 wxMenu *arg1 = (wxMenu *) 0 ;
39379 int arg2 ;
39380 wxString *arg3 = 0 ;
39381 wxMenu *arg4 = (wxMenu *) 0 ;
39382 wxString const &arg5_defvalue = wxPyEmptyString ;
39383 wxString *arg5 = (wxString *) &arg5_defvalue ;
39384 wxMenuItem *result = 0 ;
39385 void *argp1 = 0 ;
39386 int res1 = 0 ;
39387 int val2 ;
39388 int ecode2 = 0 ;
39389 bool temp3 = false ;
39390 void *argp4 = 0 ;
39391 int res4 = 0 ;
39392 bool temp5 = false ;
39393 PyObject * obj0 = 0 ;
39394 PyObject * obj1 = 0 ;
39395 PyObject * obj2 = 0 ;
39396 PyObject * obj3 = 0 ;
39397 PyObject * obj4 = 0 ;
39398 char * kwnames[] = {
39399 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39400 };
39401
39402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39404 if (!SWIG_IsOK(res1)) {
39405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39406 }
39407 arg1 = reinterpret_cast< wxMenu * >(argp1);
39408 ecode2 = SWIG_AsVal_int(obj1, &val2);
39409 if (!SWIG_IsOK(ecode2)) {
39410 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
39411 }
39412 arg2 = static_cast< int >(val2);
39413 {
39414 arg3 = wxString_in_helper(obj2);
39415 if (arg3 == NULL) SWIG_fail;
39416 temp3 = true;
39417 }
39418 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39419 if (!SWIG_IsOK(res4)) {
39420 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39421 }
39422 arg4 = reinterpret_cast< wxMenu * >(argp4);
39423 if (obj4) {
39424 {
39425 arg5 = wxString_in_helper(obj4);
39426 if (arg5 == NULL) SWIG_fail;
39427 temp5 = true;
39428 }
39429 }
39430 {
39431 PyThreadState* __tstate = wxPyBeginAllowThreads();
39432 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39433 wxPyEndAllowThreads(__tstate);
39434 if (PyErr_Occurred()) SWIG_fail;
39435 }
39436 {
39437 resultobj = wxPyMake_wxObject(result, (bool)0);
39438 }
39439 {
39440 if (temp3)
39441 delete arg3;
39442 }
39443 {
39444 if (temp5)
39445 delete arg5;
39446 }
39447 return resultobj;
39448 fail:
39449 {
39450 if (temp3)
39451 delete arg3;
39452 }
39453 {
39454 if (temp5)
39455 delete arg5;
39456 }
39457 return NULL;
39458 }
39459
39460
39461 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39462 PyObject *resultobj = 0;
39463 wxMenu *arg1 = (wxMenu *) 0 ;
39464 wxMenu *arg2 = (wxMenu *) 0 ;
39465 wxString *arg3 = 0 ;
39466 wxString const &arg4_defvalue = wxPyEmptyString ;
39467 wxString *arg4 = (wxString *) &arg4_defvalue ;
39468 wxMenuItem *result = 0 ;
39469 void *argp1 = 0 ;
39470 int res1 = 0 ;
39471 void *argp2 = 0 ;
39472 int res2 = 0 ;
39473 bool temp3 = false ;
39474 bool temp4 = false ;
39475 PyObject * obj0 = 0 ;
39476 PyObject * obj1 = 0 ;
39477 PyObject * obj2 = 0 ;
39478 PyObject * obj3 = 0 ;
39479 char * kwnames[] = {
39480 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
39481 };
39482
39483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39485 if (!SWIG_IsOK(res1)) {
39486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39487 }
39488 arg1 = reinterpret_cast< wxMenu * >(argp1);
39489 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39490 if (!SWIG_IsOK(res2)) {
39491 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
39492 }
39493 arg2 = reinterpret_cast< wxMenu * >(argp2);
39494 {
39495 arg3 = wxString_in_helper(obj2);
39496 if (arg3 == NULL) SWIG_fail;
39497 temp3 = true;
39498 }
39499 if (obj3) {
39500 {
39501 arg4 = wxString_in_helper(obj3);
39502 if (arg4 == NULL) SWIG_fail;
39503 temp4 = true;
39504 }
39505 }
39506 {
39507 PyThreadState* __tstate = wxPyBeginAllowThreads();
39508 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39509 wxPyEndAllowThreads(__tstate);
39510 if (PyErr_Occurred()) SWIG_fail;
39511 }
39512 {
39513 resultobj = wxPyMake_wxObject(result, (bool)0);
39514 }
39515 {
39516 if (temp3)
39517 delete arg3;
39518 }
39519 {
39520 if (temp4)
39521 delete arg4;
39522 }
39523 return resultobj;
39524 fail:
39525 {
39526 if (temp3)
39527 delete arg3;
39528 }
39529 {
39530 if (temp4)
39531 delete arg4;
39532 }
39533 return NULL;
39534 }
39535
39536
39537 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39538 PyObject *resultobj = 0;
39539 wxMenu *arg1 = (wxMenu *) 0 ;
39540 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39541 wxMenuItem *result = 0 ;
39542 void *argp1 = 0 ;
39543 int res1 = 0 ;
39544 int res2 = 0 ;
39545 PyObject * obj0 = 0 ;
39546 PyObject * obj1 = 0 ;
39547 char * kwnames[] = {
39548 (char *) "self",(char *) "item", NULL
39549 };
39550
39551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
39552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39553 if (!SWIG_IsOK(res1)) {
39554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39555 }
39556 arg1 = reinterpret_cast< wxMenu * >(argp1);
39557 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39558 if (!SWIG_IsOK(res2)) {
39559 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39560 }
39561 {
39562 PyThreadState* __tstate = wxPyBeginAllowThreads();
39563 result = (wxMenuItem *)(arg1)->Append(arg2);
39564 wxPyEndAllowThreads(__tstate);
39565 if (PyErr_Occurred()) SWIG_fail;
39566 }
39567 {
39568 resultobj = wxPyMake_wxObject(result, (bool)0);
39569 }
39570 return resultobj;
39571 fail:
39572 return NULL;
39573 }
39574
39575
39576 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39577 PyObject *resultobj = 0;
39578 wxMenu *arg1 = (wxMenu *) 0 ;
39579 size_t arg2 ;
39580 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
39581 wxMenuItem *result = 0 ;
39582 void *argp1 = 0 ;
39583 int res1 = 0 ;
39584 size_t val2 ;
39585 int ecode2 = 0 ;
39586 int res3 = 0 ;
39587 PyObject * obj0 = 0 ;
39588 PyObject * obj1 = 0 ;
39589 PyObject * obj2 = 0 ;
39590 char * kwnames[] = {
39591 (char *) "self",(char *) "pos",(char *) "item", NULL
39592 };
39593
39594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39596 if (!SWIG_IsOK(res1)) {
39597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39598 }
39599 arg1 = reinterpret_cast< wxMenu * >(argp1);
39600 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39601 if (!SWIG_IsOK(ecode2)) {
39602 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
39603 }
39604 arg2 = static_cast< size_t >(val2);
39605 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39606 if (!SWIG_IsOK(res3)) {
39607 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
39608 }
39609 {
39610 PyThreadState* __tstate = wxPyBeginAllowThreads();
39611 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
39612 wxPyEndAllowThreads(__tstate);
39613 if (PyErr_Occurred()) SWIG_fail;
39614 }
39615 {
39616 resultobj = wxPyMake_wxObject(result, (bool)0);
39617 }
39618 return resultobj;
39619 fail:
39620 return NULL;
39621 }
39622
39623
39624 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39625 PyObject *resultobj = 0;
39626 wxMenu *arg1 = (wxMenu *) 0 ;
39627 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39628 wxMenuItem *result = 0 ;
39629 void *argp1 = 0 ;
39630 int res1 = 0 ;
39631 int res2 = 0 ;
39632 PyObject * obj0 = 0 ;
39633 PyObject * obj1 = 0 ;
39634 char * kwnames[] = {
39635 (char *) "self",(char *) "item", NULL
39636 };
39637
39638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
39639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39640 if (!SWIG_IsOK(res1)) {
39641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39642 }
39643 arg1 = reinterpret_cast< wxMenu * >(argp1);
39644 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39645 if (!SWIG_IsOK(res2)) {
39646 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39647 }
39648 {
39649 PyThreadState* __tstate = wxPyBeginAllowThreads();
39650 result = (wxMenuItem *)(arg1)->Prepend(arg2);
39651 wxPyEndAllowThreads(__tstate);
39652 if (PyErr_Occurred()) SWIG_fail;
39653 }
39654 {
39655 resultobj = wxPyMake_wxObject(result, (bool)0);
39656 }
39657 return resultobj;
39658 fail:
39659 return NULL;
39660 }
39661
39662
39663 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39664 PyObject *resultobj = 0;
39665 wxMenu *arg1 = (wxMenu *) 0 ;
39666 void *argp1 = 0 ;
39667 int res1 = 0 ;
39668 PyObject *swig_obj[1] ;
39669
39670 if (!args) SWIG_fail;
39671 swig_obj[0] = args;
39672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39673 if (!SWIG_IsOK(res1)) {
39674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
39675 }
39676 arg1 = reinterpret_cast< wxMenu * >(argp1);
39677 {
39678 PyThreadState* __tstate = wxPyBeginAllowThreads();
39679 (arg1)->Break();
39680 wxPyEndAllowThreads(__tstate);
39681 if (PyErr_Occurred()) SWIG_fail;
39682 }
39683 resultobj = SWIG_Py_Void();
39684 return resultobj;
39685 fail:
39686 return NULL;
39687 }
39688
39689
39690 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39691 PyObject *resultobj = 0;
39692 wxMenu *arg1 = (wxMenu *) 0 ;
39693 size_t arg2 ;
39694 int arg3 ;
39695 wxString const &arg4_defvalue = wxPyEmptyString ;
39696 wxString *arg4 = (wxString *) &arg4_defvalue ;
39697 wxString const &arg5_defvalue = wxPyEmptyString ;
39698 wxString *arg5 = (wxString *) &arg5_defvalue ;
39699 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
39700 wxMenuItem *result = 0 ;
39701 void *argp1 = 0 ;
39702 int res1 = 0 ;
39703 size_t val2 ;
39704 int ecode2 = 0 ;
39705 int val3 ;
39706 int ecode3 = 0 ;
39707 bool temp4 = false ;
39708 bool temp5 = false ;
39709 int val6 ;
39710 int ecode6 = 0 ;
39711 PyObject * obj0 = 0 ;
39712 PyObject * obj1 = 0 ;
39713 PyObject * obj2 = 0 ;
39714 PyObject * obj3 = 0 ;
39715 PyObject * obj4 = 0 ;
39716 PyObject * obj5 = 0 ;
39717 char * kwnames[] = {
39718 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39719 };
39720
39721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39723 if (!SWIG_IsOK(res1)) {
39724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
39725 }
39726 arg1 = reinterpret_cast< wxMenu * >(argp1);
39727 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39728 if (!SWIG_IsOK(ecode2)) {
39729 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
39730 }
39731 arg2 = static_cast< size_t >(val2);
39732 ecode3 = SWIG_AsVal_int(obj2, &val3);
39733 if (!SWIG_IsOK(ecode3)) {
39734 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
39735 }
39736 arg3 = static_cast< int >(val3);
39737 if (obj3) {
39738 {
39739 arg4 = wxString_in_helper(obj3);
39740 if (arg4 == NULL) SWIG_fail;
39741 temp4 = true;
39742 }
39743 }
39744 if (obj4) {
39745 {
39746 arg5 = wxString_in_helper(obj4);
39747 if (arg5 == NULL) SWIG_fail;
39748 temp5 = true;
39749 }
39750 }
39751 if (obj5) {
39752 ecode6 = SWIG_AsVal_int(obj5, &val6);
39753 if (!SWIG_IsOK(ecode6)) {
39754 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
39755 }
39756 arg6 = static_cast< wxItemKind >(val6);
39757 }
39758 {
39759 PyThreadState* __tstate = wxPyBeginAllowThreads();
39760 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
39761 wxPyEndAllowThreads(__tstate);
39762 if (PyErr_Occurred()) SWIG_fail;
39763 }
39764 {
39765 resultobj = wxPyMake_wxObject(result, (bool)0);
39766 }
39767 {
39768 if (temp4)
39769 delete arg4;
39770 }
39771 {
39772 if (temp5)
39773 delete arg5;
39774 }
39775 return resultobj;
39776 fail:
39777 {
39778 if (temp4)
39779 delete arg4;
39780 }
39781 {
39782 if (temp5)
39783 delete arg5;
39784 }
39785 return NULL;
39786 }
39787
39788
39789 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39790 PyObject *resultobj = 0;
39791 wxMenu *arg1 = (wxMenu *) 0 ;
39792 size_t arg2 ;
39793 wxMenuItem *result = 0 ;
39794 void *argp1 = 0 ;
39795 int res1 = 0 ;
39796 size_t val2 ;
39797 int ecode2 = 0 ;
39798 PyObject * obj0 = 0 ;
39799 PyObject * obj1 = 0 ;
39800 char * kwnames[] = {
39801 (char *) "self",(char *) "pos", NULL
39802 };
39803
39804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
39805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39806 if (!SWIG_IsOK(res1)) {
39807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39808 }
39809 arg1 = reinterpret_cast< wxMenu * >(argp1);
39810 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39811 if (!SWIG_IsOK(ecode2)) {
39812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
39813 }
39814 arg2 = static_cast< size_t >(val2);
39815 {
39816 PyThreadState* __tstate = wxPyBeginAllowThreads();
39817 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
39818 wxPyEndAllowThreads(__tstate);
39819 if (PyErr_Occurred()) SWIG_fail;
39820 }
39821 {
39822 resultobj = wxPyMake_wxObject(result, (bool)0);
39823 }
39824 return resultobj;
39825 fail:
39826 return NULL;
39827 }
39828
39829
39830 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39831 PyObject *resultobj = 0;
39832 wxMenu *arg1 = (wxMenu *) 0 ;
39833 size_t arg2 ;
39834 int arg3 ;
39835 wxString *arg4 = 0 ;
39836 wxString const &arg5_defvalue = wxPyEmptyString ;
39837 wxString *arg5 = (wxString *) &arg5_defvalue ;
39838 wxMenuItem *result = 0 ;
39839 void *argp1 = 0 ;
39840 int res1 = 0 ;
39841 size_t val2 ;
39842 int ecode2 = 0 ;
39843 int val3 ;
39844 int ecode3 = 0 ;
39845 bool temp4 = false ;
39846 bool temp5 = false ;
39847 PyObject * obj0 = 0 ;
39848 PyObject * obj1 = 0 ;
39849 PyObject * obj2 = 0 ;
39850 PyObject * obj3 = 0 ;
39851 PyObject * obj4 = 0 ;
39852 char * kwnames[] = {
39853 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39854 };
39855
39856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39858 if (!SWIG_IsOK(res1)) {
39859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39860 }
39861 arg1 = reinterpret_cast< wxMenu * >(argp1);
39862 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39863 if (!SWIG_IsOK(ecode2)) {
39864 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
39865 }
39866 arg2 = static_cast< size_t >(val2);
39867 ecode3 = SWIG_AsVal_int(obj2, &val3);
39868 if (!SWIG_IsOK(ecode3)) {
39869 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
39870 }
39871 arg3 = static_cast< int >(val3);
39872 {
39873 arg4 = wxString_in_helper(obj3);
39874 if (arg4 == NULL) SWIG_fail;
39875 temp4 = true;
39876 }
39877 if (obj4) {
39878 {
39879 arg5 = wxString_in_helper(obj4);
39880 if (arg5 == NULL) SWIG_fail;
39881 temp5 = true;
39882 }
39883 }
39884 {
39885 PyThreadState* __tstate = wxPyBeginAllowThreads();
39886 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39887 wxPyEndAllowThreads(__tstate);
39888 if (PyErr_Occurred()) SWIG_fail;
39889 }
39890 {
39891 resultobj = wxPyMake_wxObject(result, (bool)0);
39892 }
39893 {
39894 if (temp4)
39895 delete arg4;
39896 }
39897 {
39898 if (temp5)
39899 delete arg5;
39900 }
39901 return resultobj;
39902 fail:
39903 {
39904 if (temp4)
39905 delete arg4;
39906 }
39907 {
39908 if (temp5)
39909 delete arg5;
39910 }
39911 return NULL;
39912 }
39913
39914
39915 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39916 PyObject *resultobj = 0;
39917 wxMenu *arg1 = (wxMenu *) 0 ;
39918 size_t arg2 ;
39919 int arg3 ;
39920 wxString *arg4 = 0 ;
39921 wxString const &arg5_defvalue = wxPyEmptyString ;
39922 wxString *arg5 = (wxString *) &arg5_defvalue ;
39923 wxMenuItem *result = 0 ;
39924 void *argp1 = 0 ;
39925 int res1 = 0 ;
39926 size_t val2 ;
39927 int ecode2 = 0 ;
39928 int val3 ;
39929 int ecode3 = 0 ;
39930 bool temp4 = false ;
39931 bool temp5 = false ;
39932 PyObject * obj0 = 0 ;
39933 PyObject * obj1 = 0 ;
39934 PyObject * obj2 = 0 ;
39935 PyObject * obj3 = 0 ;
39936 PyObject * obj4 = 0 ;
39937 char * kwnames[] = {
39938 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39939 };
39940
39941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39943 if (!SWIG_IsOK(res1)) {
39944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39945 }
39946 arg1 = reinterpret_cast< wxMenu * >(argp1);
39947 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39948 if (!SWIG_IsOK(ecode2)) {
39949 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
39950 }
39951 arg2 = static_cast< size_t >(val2);
39952 ecode3 = SWIG_AsVal_int(obj2, &val3);
39953 if (!SWIG_IsOK(ecode3)) {
39954 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
39955 }
39956 arg3 = static_cast< int >(val3);
39957 {
39958 arg4 = wxString_in_helper(obj3);
39959 if (arg4 == NULL) SWIG_fail;
39960 temp4 = true;
39961 }
39962 if (obj4) {
39963 {
39964 arg5 = wxString_in_helper(obj4);
39965 if (arg5 == NULL) SWIG_fail;
39966 temp5 = true;
39967 }
39968 }
39969 {
39970 PyThreadState* __tstate = wxPyBeginAllowThreads();
39971 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39972 wxPyEndAllowThreads(__tstate);
39973 if (PyErr_Occurred()) SWIG_fail;
39974 }
39975 {
39976 resultobj = wxPyMake_wxObject(result, (bool)0);
39977 }
39978 {
39979 if (temp4)
39980 delete arg4;
39981 }
39982 {
39983 if (temp5)
39984 delete arg5;
39985 }
39986 return resultobj;
39987 fail:
39988 {
39989 if (temp4)
39990 delete arg4;
39991 }
39992 {
39993 if (temp5)
39994 delete arg5;
39995 }
39996 return NULL;
39997 }
39998
39999
40000 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40001 PyObject *resultobj = 0;
40002 wxMenu *arg1 = (wxMenu *) 0 ;
40003 size_t arg2 ;
40004 int arg3 ;
40005 wxString *arg4 = 0 ;
40006 wxMenu *arg5 = (wxMenu *) 0 ;
40007 wxString const &arg6_defvalue = wxPyEmptyString ;
40008 wxString *arg6 = (wxString *) &arg6_defvalue ;
40009 wxMenuItem *result = 0 ;
40010 void *argp1 = 0 ;
40011 int res1 = 0 ;
40012 size_t val2 ;
40013 int ecode2 = 0 ;
40014 int val3 ;
40015 int ecode3 = 0 ;
40016 bool temp4 = false ;
40017 void *argp5 = 0 ;
40018 int res5 = 0 ;
40019 bool temp6 = false ;
40020 PyObject * obj0 = 0 ;
40021 PyObject * obj1 = 0 ;
40022 PyObject * obj2 = 0 ;
40023 PyObject * obj3 = 0 ;
40024 PyObject * obj4 = 0 ;
40025 PyObject * obj5 = 0 ;
40026 char * kwnames[] = {
40027 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
40028 };
40029
40030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
40031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40032 if (!SWIG_IsOK(res1)) {
40033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
40034 }
40035 arg1 = reinterpret_cast< wxMenu * >(argp1);
40036 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40037 if (!SWIG_IsOK(ecode2)) {
40038 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
40039 }
40040 arg2 = static_cast< size_t >(val2);
40041 ecode3 = SWIG_AsVal_int(obj2, &val3);
40042 if (!SWIG_IsOK(ecode3)) {
40043 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
40044 }
40045 arg3 = static_cast< int >(val3);
40046 {
40047 arg4 = wxString_in_helper(obj3);
40048 if (arg4 == NULL) SWIG_fail;
40049 temp4 = true;
40050 }
40051 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
40052 if (!SWIG_IsOK(res5)) {
40053 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
40054 }
40055 arg5 = reinterpret_cast< wxMenu * >(argp5);
40056 if (obj5) {
40057 {
40058 arg6 = wxString_in_helper(obj5);
40059 if (arg6 == NULL) SWIG_fail;
40060 temp6 = true;
40061 }
40062 }
40063 {
40064 PyThreadState* __tstate = wxPyBeginAllowThreads();
40065 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
40066 wxPyEndAllowThreads(__tstate);
40067 if (PyErr_Occurred()) SWIG_fail;
40068 }
40069 {
40070 resultobj = wxPyMake_wxObject(result, (bool)0);
40071 }
40072 {
40073 if (temp4)
40074 delete arg4;
40075 }
40076 {
40077 if (temp6)
40078 delete arg6;
40079 }
40080 return resultobj;
40081 fail:
40082 {
40083 if (temp4)
40084 delete arg4;
40085 }
40086 {
40087 if (temp6)
40088 delete arg6;
40089 }
40090 return NULL;
40091 }
40092
40093
40094 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40095 PyObject *resultobj = 0;
40096 wxMenu *arg1 = (wxMenu *) 0 ;
40097 int arg2 ;
40098 wxString const &arg3_defvalue = wxPyEmptyString ;
40099 wxString *arg3 = (wxString *) &arg3_defvalue ;
40100 wxString const &arg4_defvalue = wxPyEmptyString ;
40101 wxString *arg4 = (wxString *) &arg4_defvalue ;
40102 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
40103 wxMenuItem *result = 0 ;
40104 void *argp1 = 0 ;
40105 int res1 = 0 ;
40106 int val2 ;
40107 int ecode2 = 0 ;
40108 bool temp3 = false ;
40109 bool temp4 = false ;
40110 int val5 ;
40111 int ecode5 = 0 ;
40112 PyObject * obj0 = 0 ;
40113 PyObject * obj1 = 0 ;
40114 PyObject * obj2 = 0 ;
40115 PyObject * obj3 = 0 ;
40116 PyObject * obj4 = 0 ;
40117 char * kwnames[] = {
40118 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
40119 };
40120
40121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
40122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40123 if (!SWIG_IsOK(res1)) {
40124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
40125 }
40126 arg1 = reinterpret_cast< wxMenu * >(argp1);
40127 ecode2 = SWIG_AsVal_int(obj1, &val2);
40128 if (!SWIG_IsOK(ecode2)) {
40129 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
40130 }
40131 arg2 = static_cast< int >(val2);
40132 if (obj2) {
40133 {
40134 arg3 = wxString_in_helper(obj2);
40135 if (arg3 == NULL) SWIG_fail;
40136 temp3 = true;
40137 }
40138 }
40139 if (obj3) {
40140 {
40141 arg4 = wxString_in_helper(obj3);
40142 if (arg4 == NULL) SWIG_fail;
40143 temp4 = true;
40144 }
40145 }
40146 if (obj4) {
40147 ecode5 = SWIG_AsVal_int(obj4, &val5);
40148 if (!SWIG_IsOK(ecode5)) {
40149 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
40150 }
40151 arg5 = static_cast< wxItemKind >(val5);
40152 }
40153 {
40154 PyThreadState* __tstate = wxPyBeginAllowThreads();
40155 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
40156 wxPyEndAllowThreads(__tstate);
40157 if (PyErr_Occurred()) SWIG_fail;
40158 }
40159 {
40160 resultobj = wxPyMake_wxObject(result, (bool)0);
40161 }
40162 {
40163 if (temp3)
40164 delete arg3;
40165 }
40166 {
40167 if (temp4)
40168 delete arg4;
40169 }
40170 return resultobj;
40171 fail:
40172 {
40173 if (temp3)
40174 delete arg3;
40175 }
40176 {
40177 if (temp4)
40178 delete arg4;
40179 }
40180 return NULL;
40181 }
40182
40183
40184 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40185 PyObject *resultobj = 0;
40186 wxMenu *arg1 = (wxMenu *) 0 ;
40187 wxMenuItem *result = 0 ;
40188 void *argp1 = 0 ;
40189 int res1 = 0 ;
40190 PyObject *swig_obj[1] ;
40191
40192 if (!args) SWIG_fail;
40193 swig_obj[0] = args;
40194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40195 if (!SWIG_IsOK(res1)) {
40196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
40197 }
40198 arg1 = reinterpret_cast< wxMenu * >(argp1);
40199 {
40200 PyThreadState* __tstate = wxPyBeginAllowThreads();
40201 result = (wxMenuItem *)(arg1)->PrependSeparator();
40202 wxPyEndAllowThreads(__tstate);
40203 if (PyErr_Occurred()) SWIG_fail;
40204 }
40205 {
40206 resultobj = wxPyMake_wxObject(result, (bool)0);
40207 }
40208 return resultobj;
40209 fail:
40210 return NULL;
40211 }
40212
40213
40214 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40215 PyObject *resultobj = 0;
40216 wxMenu *arg1 = (wxMenu *) 0 ;
40217 int arg2 ;
40218 wxString *arg3 = 0 ;
40219 wxString const &arg4_defvalue = wxPyEmptyString ;
40220 wxString *arg4 = (wxString *) &arg4_defvalue ;
40221 wxMenuItem *result = 0 ;
40222 void *argp1 = 0 ;
40223 int res1 = 0 ;
40224 int val2 ;
40225 int ecode2 = 0 ;
40226 bool temp3 = false ;
40227 bool temp4 = false ;
40228 PyObject * obj0 = 0 ;
40229 PyObject * obj1 = 0 ;
40230 PyObject * obj2 = 0 ;
40231 PyObject * obj3 = 0 ;
40232 char * kwnames[] = {
40233 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
40234 };
40235
40236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40238 if (!SWIG_IsOK(res1)) {
40239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40240 }
40241 arg1 = reinterpret_cast< wxMenu * >(argp1);
40242 ecode2 = SWIG_AsVal_int(obj1, &val2);
40243 if (!SWIG_IsOK(ecode2)) {
40244 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
40245 }
40246 arg2 = static_cast< int >(val2);
40247 {
40248 arg3 = wxString_in_helper(obj2);
40249 if (arg3 == NULL) SWIG_fail;
40250 temp3 = true;
40251 }
40252 if (obj3) {
40253 {
40254 arg4 = wxString_in_helper(obj3);
40255 if (arg4 == NULL) SWIG_fail;
40256 temp4 = true;
40257 }
40258 }
40259 {
40260 PyThreadState* __tstate = wxPyBeginAllowThreads();
40261 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
40262 wxPyEndAllowThreads(__tstate);
40263 if (PyErr_Occurred()) SWIG_fail;
40264 }
40265 {
40266 resultobj = wxPyMake_wxObject(result, (bool)0);
40267 }
40268 {
40269 if (temp3)
40270 delete arg3;
40271 }
40272 {
40273 if (temp4)
40274 delete arg4;
40275 }
40276 return resultobj;
40277 fail:
40278 {
40279 if (temp3)
40280 delete arg3;
40281 }
40282 {
40283 if (temp4)
40284 delete arg4;
40285 }
40286 return NULL;
40287 }
40288
40289
40290 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40291 PyObject *resultobj = 0;
40292 wxMenu *arg1 = (wxMenu *) 0 ;
40293 int arg2 ;
40294 wxString *arg3 = 0 ;
40295 wxString const &arg4_defvalue = wxPyEmptyString ;
40296 wxString *arg4 = (wxString *) &arg4_defvalue ;
40297 wxMenuItem *result = 0 ;
40298 void *argp1 = 0 ;
40299 int res1 = 0 ;
40300 int val2 ;
40301 int ecode2 = 0 ;
40302 bool temp3 = false ;
40303 bool temp4 = false ;
40304 PyObject * obj0 = 0 ;
40305 PyObject * obj1 = 0 ;
40306 PyObject * obj2 = 0 ;
40307 PyObject * obj3 = 0 ;
40308 char * kwnames[] = {
40309 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
40310 };
40311
40312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40314 if (!SWIG_IsOK(res1)) {
40315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40316 }
40317 arg1 = reinterpret_cast< wxMenu * >(argp1);
40318 ecode2 = SWIG_AsVal_int(obj1, &val2);
40319 if (!SWIG_IsOK(ecode2)) {
40320 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
40321 }
40322 arg2 = static_cast< int >(val2);
40323 {
40324 arg3 = wxString_in_helper(obj2);
40325 if (arg3 == NULL) SWIG_fail;
40326 temp3 = true;
40327 }
40328 if (obj3) {
40329 {
40330 arg4 = wxString_in_helper(obj3);
40331 if (arg4 == NULL) SWIG_fail;
40332 temp4 = true;
40333 }
40334 }
40335 {
40336 PyThreadState* __tstate = wxPyBeginAllowThreads();
40337 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
40338 wxPyEndAllowThreads(__tstate);
40339 if (PyErr_Occurred()) SWIG_fail;
40340 }
40341 {
40342 resultobj = wxPyMake_wxObject(result, (bool)0);
40343 }
40344 {
40345 if (temp3)
40346 delete arg3;
40347 }
40348 {
40349 if (temp4)
40350 delete arg4;
40351 }
40352 return resultobj;
40353 fail:
40354 {
40355 if (temp3)
40356 delete arg3;
40357 }
40358 {
40359 if (temp4)
40360 delete arg4;
40361 }
40362 return NULL;
40363 }
40364
40365
40366 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40367 PyObject *resultobj = 0;
40368 wxMenu *arg1 = (wxMenu *) 0 ;
40369 int arg2 ;
40370 wxString *arg3 = 0 ;
40371 wxMenu *arg4 = (wxMenu *) 0 ;
40372 wxString const &arg5_defvalue = wxPyEmptyString ;
40373 wxString *arg5 = (wxString *) &arg5_defvalue ;
40374 wxMenuItem *result = 0 ;
40375 void *argp1 = 0 ;
40376 int res1 = 0 ;
40377 int val2 ;
40378 int ecode2 = 0 ;
40379 bool temp3 = false ;
40380 void *argp4 = 0 ;
40381 int res4 = 0 ;
40382 bool temp5 = false ;
40383 PyObject * obj0 = 0 ;
40384 PyObject * obj1 = 0 ;
40385 PyObject * obj2 = 0 ;
40386 PyObject * obj3 = 0 ;
40387 PyObject * obj4 = 0 ;
40388 char * kwnames[] = {
40389 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
40390 };
40391
40392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
40393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40394 if (!SWIG_IsOK(res1)) {
40395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
40396 }
40397 arg1 = reinterpret_cast< wxMenu * >(argp1);
40398 ecode2 = SWIG_AsVal_int(obj1, &val2);
40399 if (!SWIG_IsOK(ecode2)) {
40400 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
40401 }
40402 arg2 = static_cast< int >(val2);
40403 {
40404 arg3 = wxString_in_helper(obj2);
40405 if (arg3 == NULL) SWIG_fail;
40406 temp3 = true;
40407 }
40408 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
40409 if (!SWIG_IsOK(res4)) {
40410 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
40411 }
40412 arg4 = reinterpret_cast< wxMenu * >(argp4);
40413 if (obj4) {
40414 {
40415 arg5 = wxString_in_helper(obj4);
40416 if (arg5 == NULL) SWIG_fail;
40417 temp5 = true;
40418 }
40419 }
40420 {
40421 PyThreadState* __tstate = wxPyBeginAllowThreads();
40422 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
40423 wxPyEndAllowThreads(__tstate);
40424 if (PyErr_Occurred()) SWIG_fail;
40425 }
40426 {
40427 resultobj = wxPyMake_wxObject(result, (bool)0);
40428 }
40429 {
40430 if (temp3)
40431 delete arg3;
40432 }
40433 {
40434 if (temp5)
40435 delete arg5;
40436 }
40437 return resultobj;
40438 fail:
40439 {
40440 if (temp3)
40441 delete arg3;
40442 }
40443 {
40444 if (temp5)
40445 delete arg5;
40446 }
40447 return NULL;
40448 }
40449
40450
40451 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40452 PyObject *resultobj = 0;
40453 wxMenu *arg1 = (wxMenu *) 0 ;
40454 int arg2 ;
40455 wxMenuItem *result = 0 ;
40456 void *argp1 = 0 ;
40457 int res1 = 0 ;
40458 int val2 ;
40459 int ecode2 = 0 ;
40460 PyObject * obj0 = 0 ;
40461 PyObject * obj1 = 0 ;
40462 char * kwnames[] = {
40463 (char *) "self",(char *) "id", NULL
40464 };
40465
40466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
40467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40468 if (!SWIG_IsOK(res1)) {
40469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
40470 }
40471 arg1 = reinterpret_cast< wxMenu * >(argp1);
40472 ecode2 = SWIG_AsVal_int(obj1, &val2);
40473 if (!SWIG_IsOK(ecode2)) {
40474 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
40475 }
40476 arg2 = static_cast< int >(val2);
40477 {
40478 PyThreadState* __tstate = wxPyBeginAllowThreads();
40479 result = (wxMenuItem *)(arg1)->Remove(arg2);
40480 wxPyEndAllowThreads(__tstate);
40481 if (PyErr_Occurred()) SWIG_fail;
40482 }
40483 {
40484 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
40485 }
40486 return resultobj;
40487 fail:
40488 return NULL;
40489 }
40490
40491
40492 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40493 PyObject *resultobj = 0;
40494 wxMenu *arg1 = (wxMenu *) 0 ;
40495 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40496 wxMenuItem *result = 0 ;
40497 void *argp1 = 0 ;
40498 int res1 = 0 ;
40499 void *argp2 = 0 ;
40500 int res2 = 0 ;
40501 PyObject * obj0 = 0 ;
40502 PyObject * obj1 = 0 ;
40503 char * kwnames[] = {
40504 (char *) "self",(char *) "item", NULL
40505 };
40506
40507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
40508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40509 if (!SWIG_IsOK(res1)) {
40510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40511 }
40512 arg1 = reinterpret_cast< wxMenu * >(argp1);
40513 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
40514 if (!SWIG_IsOK(res2)) {
40515 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40516 }
40517 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
40518 {
40519 PyThreadState* __tstate = wxPyBeginAllowThreads();
40520 result = (wxMenuItem *)(arg1)->Remove(arg2);
40521 wxPyEndAllowThreads(__tstate);
40522 if (PyErr_Occurred()) SWIG_fail;
40523 }
40524 {
40525 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
40526 }
40527 return resultobj;
40528 fail:
40529 return NULL;
40530 }
40531
40532
40533 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40534 PyObject *resultobj = 0;
40535 wxMenu *arg1 = (wxMenu *) 0 ;
40536 int arg2 ;
40537 bool result;
40538 void *argp1 = 0 ;
40539 int res1 = 0 ;
40540 int val2 ;
40541 int ecode2 = 0 ;
40542 PyObject * obj0 = 0 ;
40543 PyObject * obj1 = 0 ;
40544 char * kwnames[] = {
40545 (char *) "self",(char *) "id", NULL
40546 };
40547
40548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
40549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40550 if (!SWIG_IsOK(res1)) {
40551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
40552 }
40553 arg1 = reinterpret_cast< wxMenu * >(argp1);
40554 ecode2 = SWIG_AsVal_int(obj1, &val2);
40555 if (!SWIG_IsOK(ecode2)) {
40556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
40557 }
40558 arg2 = static_cast< int >(val2);
40559 {
40560 PyThreadState* __tstate = wxPyBeginAllowThreads();
40561 result = (bool)(arg1)->Delete(arg2);
40562 wxPyEndAllowThreads(__tstate);
40563 if (PyErr_Occurred()) SWIG_fail;
40564 }
40565 {
40566 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40567 }
40568 return resultobj;
40569 fail:
40570 return NULL;
40571 }
40572
40573
40574 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40575 PyObject *resultobj = 0;
40576 wxMenu *arg1 = (wxMenu *) 0 ;
40577 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40578 bool result;
40579 void *argp1 = 0 ;
40580 int res1 = 0 ;
40581 void *argp2 = 0 ;
40582 int res2 = 0 ;
40583 PyObject * obj0 = 0 ;
40584 PyObject * obj1 = 0 ;
40585 char * kwnames[] = {
40586 (char *) "self",(char *) "item", NULL
40587 };
40588
40589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
40590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40591 if (!SWIG_IsOK(res1)) {
40592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40593 }
40594 arg1 = reinterpret_cast< wxMenu * >(argp1);
40595 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
40596 if (!SWIG_IsOK(res2)) {
40597 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40598 }
40599 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
40600 {
40601 PyThreadState* __tstate = wxPyBeginAllowThreads();
40602 result = (bool)(arg1)->Delete(arg2);
40603 wxPyEndAllowThreads(__tstate);
40604 if (PyErr_Occurred()) SWIG_fail;
40605 }
40606 {
40607 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40608 }
40609 return resultobj;
40610 fail:
40611 return NULL;
40612 }
40613
40614
40615 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40616 PyObject *resultobj = 0;
40617 wxMenu *arg1 = (wxMenu *) 0 ;
40618 void *argp1 = 0 ;
40619 int res1 = 0 ;
40620 PyObject *swig_obj[1] ;
40621
40622 if (!args) SWIG_fail;
40623 swig_obj[0] = args;
40624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40625 if (!SWIG_IsOK(res1)) {
40626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
40627 }
40628 arg1 = reinterpret_cast< wxMenu * >(argp1);
40629 {
40630 PyThreadState* __tstate = wxPyBeginAllowThreads();
40631 wxMenu_Destroy(arg1);
40632 wxPyEndAllowThreads(__tstate);
40633 if (PyErr_Occurred()) SWIG_fail;
40634 }
40635 resultobj = SWIG_Py_Void();
40636 return resultobj;
40637 fail:
40638 return NULL;
40639 }
40640
40641
40642 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40643 PyObject *resultobj = 0;
40644 wxMenu *arg1 = (wxMenu *) 0 ;
40645 int arg2 ;
40646 bool result;
40647 void *argp1 = 0 ;
40648 int res1 = 0 ;
40649 int val2 ;
40650 int ecode2 = 0 ;
40651 PyObject * obj0 = 0 ;
40652 PyObject * obj1 = 0 ;
40653 char * kwnames[] = {
40654 (char *) "self",(char *) "id", NULL
40655 };
40656
40657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
40658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40659 if (!SWIG_IsOK(res1)) {
40660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
40661 }
40662 arg1 = reinterpret_cast< wxMenu * >(argp1);
40663 ecode2 = SWIG_AsVal_int(obj1, &val2);
40664 if (!SWIG_IsOK(ecode2)) {
40665 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
40666 }
40667 arg2 = static_cast< int >(val2);
40668 {
40669 PyThreadState* __tstate = wxPyBeginAllowThreads();
40670 result = (bool)(arg1)->Destroy(arg2);
40671 wxPyEndAllowThreads(__tstate);
40672 if (PyErr_Occurred()) SWIG_fail;
40673 }
40674 {
40675 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40676 }
40677 return resultobj;
40678 fail:
40679 return NULL;
40680 }
40681
40682
40683 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40684 PyObject *resultobj = 0;
40685 wxMenu *arg1 = (wxMenu *) 0 ;
40686 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40687 bool result;
40688 void *argp1 = 0 ;
40689 int res1 = 0 ;
40690 void *argp2 = 0 ;
40691 int res2 = 0 ;
40692 PyObject * obj0 = 0 ;
40693 PyObject * obj1 = 0 ;
40694 char * kwnames[] = {
40695 (char *) "self",(char *) "item", NULL
40696 };
40697
40698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
40699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40700 if (!SWIG_IsOK(res1)) {
40701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40702 }
40703 arg1 = reinterpret_cast< wxMenu * >(argp1);
40704 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
40705 if (!SWIG_IsOK(res2)) {
40706 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40707 }
40708 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
40709 {
40710 PyThreadState* __tstate = wxPyBeginAllowThreads();
40711 result = (bool)(arg1)->Destroy(arg2);
40712 wxPyEndAllowThreads(__tstate);
40713 if (PyErr_Occurred()) SWIG_fail;
40714 }
40715 {
40716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40717 }
40718 return resultobj;
40719 fail:
40720 return NULL;
40721 }
40722
40723
40724 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40725 PyObject *resultobj = 0;
40726 wxMenu *arg1 = (wxMenu *) 0 ;
40727 size_t result;
40728 void *argp1 = 0 ;
40729 int res1 = 0 ;
40730 PyObject *swig_obj[1] ;
40731
40732 if (!args) SWIG_fail;
40733 swig_obj[0] = args;
40734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40735 if (!SWIG_IsOK(res1)) {
40736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
40737 }
40738 arg1 = reinterpret_cast< wxMenu * >(argp1);
40739 {
40740 PyThreadState* __tstate = wxPyBeginAllowThreads();
40741 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
40742 wxPyEndAllowThreads(__tstate);
40743 if (PyErr_Occurred()) SWIG_fail;
40744 }
40745 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
40746 return resultobj;
40747 fail:
40748 return NULL;
40749 }
40750
40751
40752 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40753 PyObject *resultobj = 0;
40754 wxMenu *arg1 = (wxMenu *) 0 ;
40755 PyObject *result = 0 ;
40756 void *argp1 = 0 ;
40757 int res1 = 0 ;
40758 PyObject *swig_obj[1] ;
40759
40760 if (!args) SWIG_fail;
40761 swig_obj[0] = args;
40762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40763 if (!SWIG_IsOK(res1)) {
40764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
40765 }
40766 arg1 = reinterpret_cast< wxMenu * >(argp1);
40767 {
40768 PyThreadState* __tstate = wxPyBeginAllowThreads();
40769 result = (PyObject *)wxMenu_GetMenuItems(arg1);
40770 wxPyEndAllowThreads(__tstate);
40771 if (PyErr_Occurred()) SWIG_fail;
40772 }
40773 resultobj = result;
40774 return resultobj;
40775 fail:
40776 return NULL;
40777 }
40778
40779
40780 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40781 PyObject *resultobj = 0;
40782 wxMenu *arg1 = (wxMenu *) 0 ;
40783 wxString *arg2 = 0 ;
40784 int result;
40785 void *argp1 = 0 ;
40786 int res1 = 0 ;
40787 bool temp2 = false ;
40788 PyObject * obj0 = 0 ;
40789 PyObject * obj1 = 0 ;
40790 char * kwnames[] = {
40791 (char *) "self",(char *) "item", NULL
40792 };
40793
40794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
40795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40796 if (!SWIG_IsOK(res1)) {
40797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
40798 }
40799 arg1 = reinterpret_cast< wxMenu * >(argp1);
40800 {
40801 arg2 = wxString_in_helper(obj1);
40802 if (arg2 == NULL) SWIG_fail;
40803 temp2 = true;
40804 }
40805 {
40806 PyThreadState* __tstate = wxPyBeginAllowThreads();
40807 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
40808 wxPyEndAllowThreads(__tstate);
40809 if (PyErr_Occurred()) SWIG_fail;
40810 }
40811 resultobj = SWIG_From_int(static_cast< int >(result));
40812 {
40813 if (temp2)
40814 delete arg2;
40815 }
40816 return resultobj;
40817 fail:
40818 {
40819 if (temp2)
40820 delete arg2;
40821 }
40822 return NULL;
40823 }
40824
40825
40826 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40827 PyObject *resultobj = 0;
40828 wxMenu *arg1 = (wxMenu *) 0 ;
40829 int arg2 ;
40830 wxMenuItem *result = 0 ;
40831 void *argp1 = 0 ;
40832 int res1 = 0 ;
40833 int val2 ;
40834 int ecode2 = 0 ;
40835 PyObject * obj0 = 0 ;
40836 PyObject * obj1 = 0 ;
40837 char * kwnames[] = {
40838 (char *) "self",(char *) "id", NULL
40839 };
40840
40841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
40842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40843 if (!SWIG_IsOK(res1)) {
40844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
40845 }
40846 arg1 = reinterpret_cast< wxMenu * >(argp1);
40847 ecode2 = SWIG_AsVal_int(obj1, &val2);
40848 if (!SWIG_IsOK(ecode2)) {
40849 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
40850 }
40851 arg2 = static_cast< int >(val2);
40852 {
40853 PyThreadState* __tstate = wxPyBeginAllowThreads();
40854 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
40855 wxPyEndAllowThreads(__tstate);
40856 if (PyErr_Occurred()) SWIG_fail;
40857 }
40858 {
40859 resultobj = wxPyMake_wxObject(result, (bool)0);
40860 }
40861 return resultobj;
40862 fail:
40863 return NULL;
40864 }
40865
40866
40867 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40868 PyObject *resultobj = 0;
40869 wxMenu *arg1 = (wxMenu *) 0 ;
40870 size_t arg2 ;
40871 wxMenuItem *result = 0 ;
40872 void *argp1 = 0 ;
40873 int res1 = 0 ;
40874 size_t val2 ;
40875 int ecode2 = 0 ;
40876 PyObject * obj0 = 0 ;
40877 PyObject * obj1 = 0 ;
40878 char * kwnames[] = {
40879 (char *) "self",(char *) "position", NULL
40880 };
40881
40882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
40883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40884 if (!SWIG_IsOK(res1)) {
40885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
40886 }
40887 arg1 = reinterpret_cast< wxMenu * >(argp1);
40888 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40889 if (!SWIG_IsOK(ecode2)) {
40890 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
40891 }
40892 arg2 = static_cast< size_t >(val2);
40893 {
40894 PyThreadState* __tstate = wxPyBeginAllowThreads();
40895 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
40896 wxPyEndAllowThreads(__tstate);
40897 if (PyErr_Occurred()) SWIG_fail;
40898 }
40899 {
40900 resultobj = wxPyMake_wxObject(result, (bool)0);
40901 }
40902 return resultobj;
40903 fail:
40904 return NULL;
40905 }
40906
40907
40908 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40909 PyObject *resultobj = 0;
40910 wxMenu *arg1 = (wxMenu *) 0 ;
40911 int arg2 ;
40912 bool arg3 ;
40913 void *argp1 = 0 ;
40914 int res1 = 0 ;
40915 int val2 ;
40916 int ecode2 = 0 ;
40917 bool val3 ;
40918 int ecode3 = 0 ;
40919 PyObject * obj0 = 0 ;
40920 PyObject * obj1 = 0 ;
40921 PyObject * obj2 = 0 ;
40922 char * kwnames[] = {
40923 (char *) "self",(char *) "id",(char *) "enable", NULL
40924 };
40925
40926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40928 if (!SWIG_IsOK(res1)) {
40929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
40930 }
40931 arg1 = reinterpret_cast< wxMenu * >(argp1);
40932 ecode2 = SWIG_AsVal_int(obj1, &val2);
40933 if (!SWIG_IsOK(ecode2)) {
40934 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
40935 }
40936 arg2 = static_cast< int >(val2);
40937 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40938 if (!SWIG_IsOK(ecode3)) {
40939 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
40940 }
40941 arg3 = static_cast< bool >(val3);
40942 {
40943 PyThreadState* __tstate = wxPyBeginAllowThreads();
40944 (arg1)->Enable(arg2,arg3);
40945 wxPyEndAllowThreads(__tstate);
40946 if (PyErr_Occurred()) SWIG_fail;
40947 }
40948 resultobj = SWIG_Py_Void();
40949 return resultobj;
40950 fail:
40951 return NULL;
40952 }
40953
40954
40955 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40956 PyObject *resultobj = 0;
40957 wxMenu *arg1 = (wxMenu *) 0 ;
40958 int arg2 ;
40959 bool result;
40960 void *argp1 = 0 ;
40961 int res1 = 0 ;
40962 int val2 ;
40963 int ecode2 = 0 ;
40964 PyObject * obj0 = 0 ;
40965 PyObject * obj1 = 0 ;
40966 char * kwnames[] = {
40967 (char *) "self",(char *) "id", NULL
40968 };
40969
40970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
40971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40972 if (!SWIG_IsOK(res1)) {
40973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
40974 }
40975 arg1 = reinterpret_cast< wxMenu * >(argp1);
40976 ecode2 = SWIG_AsVal_int(obj1, &val2);
40977 if (!SWIG_IsOK(ecode2)) {
40978 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
40979 }
40980 arg2 = static_cast< int >(val2);
40981 {
40982 PyThreadState* __tstate = wxPyBeginAllowThreads();
40983 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
40984 wxPyEndAllowThreads(__tstate);
40985 if (PyErr_Occurred()) SWIG_fail;
40986 }
40987 {
40988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40989 }
40990 return resultobj;
40991 fail:
40992 return NULL;
40993 }
40994
40995
40996 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40997 PyObject *resultobj = 0;
40998 wxMenu *arg1 = (wxMenu *) 0 ;
40999 int arg2 ;
41000 bool arg3 ;
41001 void *argp1 = 0 ;
41002 int res1 = 0 ;
41003 int val2 ;
41004 int ecode2 = 0 ;
41005 bool val3 ;
41006 int ecode3 = 0 ;
41007 PyObject * obj0 = 0 ;
41008 PyObject * obj1 = 0 ;
41009 PyObject * obj2 = 0 ;
41010 char * kwnames[] = {
41011 (char *) "self",(char *) "id",(char *) "check", NULL
41012 };
41013
41014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41016 if (!SWIG_IsOK(res1)) {
41017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
41018 }
41019 arg1 = reinterpret_cast< wxMenu * >(argp1);
41020 ecode2 = SWIG_AsVal_int(obj1, &val2);
41021 if (!SWIG_IsOK(ecode2)) {
41022 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
41023 }
41024 arg2 = static_cast< int >(val2);
41025 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41026 if (!SWIG_IsOK(ecode3)) {
41027 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
41028 }
41029 arg3 = static_cast< bool >(val3);
41030 {
41031 PyThreadState* __tstate = wxPyBeginAllowThreads();
41032 (arg1)->Check(arg2,arg3);
41033 wxPyEndAllowThreads(__tstate);
41034 if (PyErr_Occurred()) SWIG_fail;
41035 }
41036 resultobj = SWIG_Py_Void();
41037 return resultobj;
41038 fail:
41039 return NULL;
41040 }
41041
41042
41043 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41044 PyObject *resultobj = 0;
41045 wxMenu *arg1 = (wxMenu *) 0 ;
41046 int arg2 ;
41047 bool result;
41048 void *argp1 = 0 ;
41049 int res1 = 0 ;
41050 int val2 ;
41051 int ecode2 = 0 ;
41052 PyObject * obj0 = 0 ;
41053 PyObject * obj1 = 0 ;
41054 char * kwnames[] = {
41055 (char *) "self",(char *) "id", NULL
41056 };
41057
41058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41060 if (!SWIG_IsOK(res1)) {
41061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
41062 }
41063 arg1 = reinterpret_cast< wxMenu * >(argp1);
41064 ecode2 = SWIG_AsVal_int(obj1, &val2);
41065 if (!SWIG_IsOK(ecode2)) {
41066 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
41067 }
41068 arg2 = static_cast< int >(val2);
41069 {
41070 PyThreadState* __tstate = wxPyBeginAllowThreads();
41071 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
41072 wxPyEndAllowThreads(__tstate);
41073 if (PyErr_Occurred()) SWIG_fail;
41074 }
41075 {
41076 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41077 }
41078 return resultobj;
41079 fail:
41080 return NULL;
41081 }
41082
41083
41084 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41085 PyObject *resultobj = 0;
41086 wxMenu *arg1 = (wxMenu *) 0 ;
41087 int arg2 ;
41088 wxString *arg3 = 0 ;
41089 void *argp1 = 0 ;
41090 int res1 = 0 ;
41091 int val2 ;
41092 int ecode2 = 0 ;
41093 bool temp3 = false ;
41094 PyObject * obj0 = 0 ;
41095 PyObject * obj1 = 0 ;
41096 PyObject * obj2 = 0 ;
41097 char * kwnames[] = {
41098 (char *) "self",(char *) "id",(char *) "label", NULL
41099 };
41100
41101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41103 if (!SWIG_IsOK(res1)) {
41104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
41105 }
41106 arg1 = reinterpret_cast< wxMenu * >(argp1);
41107 ecode2 = SWIG_AsVal_int(obj1, &val2);
41108 if (!SWIG_IsOK(ecode2)) {
41109 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
41110 }
41111 arg2 = static_cast< int >(val2);
41112 {
41113 arg3 = wxString_in_helper(obj2);
41114 if (arg3 == NULL) SWIG_fail;
41115 temp3 = true;
41116 }
41117 {
41118 PyThreadState* __tstate = wxPyBeginAllowThreads();
41119 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
41120 wxPyEndAllowThreads(__tstate);
41121 if (PyErr_Occurred()) SWIG_fail;
41122 }
41123 resultobj = SWIG_Py_Void();
41124 {
41125 if (temp3)
41126 delete arg3;
41127 }
41128 return resultobj;
41129 fail:
41130 {
41131 if (temp3)
41132 delete arg3;
41133 }
41134 return NULL;
41135 }
41136
41137
41138 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41139 PyObject *resultobj = 0;
41140 wxMenu *arg1 = (wxMenu *) 0 ;
41141 int arg2 ;
41142 wxString result;
41143 void *argp1 = 0 ;
41144 int res1 = 0 ;
41145 int val2 ;
41146 int ecode2 = 0 ;
41147 PyObject * obj0 = 0 ;
41148 PyObject * obj1 = 0 ;
41149 char * kwnames[] = {
41150 (char *) "self",(char *) "id", NULL
41151 };
41152
41153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41155 if (!SWIG_IsOK(res1)) {
41156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
41157 }
41158 arg1 = reinterpret_cast< wxMenu * >(argp1);
41159 ecode2 = SWIG_AsVal_int(obj1, &val2);
41160 if (!SWIG_IsOK(ecode2)) {
41161 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
41162 }
41163 arg2 = static_cast< int >(val2);
41164 {
41165 PyThreadState* __tstate = wxPyBeginAllowThreads();
41166 result = ((wxMenu const *)arg1)->GetLabel(arg2);
41167 wxPyEndAllowThreads(__tstate);
41168 if (PyErr_Occurred()) SWIG_fail;
41169 }
41170 {
41171 #if wxUSE_UNICODE
41172 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41173 #else
41174 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41175 #endif
41176 }
41177 return resultobj;
41178 fail:
41179 return NULL;
41180 }
41181
41182
41183 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41184 PyObject *resultobj = 0;
41185 wxMenu *arg1 = (wxMenu *) 0 ;
41186 int arg2 ;
41187 wxString *arg3 = 0 ;
41188 void *argp1 = 0 ;
41189 int res1 = 0 ;
41190 int val2 ;
41191 int ecode2 = 0 ;
41192 bool temp3 = false ;
41193 PyObject * obj0 = 0 ;
41194 PyObject * obj1 = 0 ;
41195 PyObject * obj2 = 0 ;
41196 char * kwnames[] = {
41197 (char *) "self",(char *) "id",(char *) "helpString", NULL
41198 };
41199
41200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41201 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41202 if (!SWIG_IsOK(res1)) {
41203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
41204 }
41205 arg1 = reinterpret_cast< wxMenu * >(argp1);
41206 ecode2 = SWIG_AsVal_int(obj1, &val2);
41207 if (!SWIG_IsOK(ecode2)) {
41208 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41209 }
41210 arg2 = static_cast< int >(val2);
41211 {
41212 arg3 = wxString_in_helper(obj2);
41213 if (arg3 == NULL) SWIG_fail;
41214 temp3 = true;
41215 }
41216 {
41217 PyThreadState* __tstate = wxPyBeginAllowThreads();
41218 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41219 wxPyEndAllowThreads(__tstate);
41220 if (PyErr_Occurred()) SWIG_fail;
41221 }
41222 resultobj = SWIG_Py_Void();
41223 {
41224 if (temp3)
41225 delete arg3;
41226 }
41227 return resultobj;
41228 fail:
41229 {
41230 if (temp3)
41231 delete arg3;
41232 }
41233 return NULL;
41234 }
41235
41236
41237 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41238 PyObject *resultobj = 0;
41239 wxMenu *arg1 = (wxMenu *) 0 ;
41240 int arg2 ;
41241 wxString result;
41242 void *argp1 = 0 ;
41243 int res1 = 0 ;
41244 int val2 ;
41245 int ecode2 = 0 ;
41246 PyObject * obj0 = 0 ;
41247 PyObject * obj1 = 0 ;
41248 char * kwnames[] = {
41249 (char *) "self",(char *) "id", NULL
41250 };
41251
41252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
41253 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41254 if (!SWIG_IsOK(res1)) {
41255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
41256 }
41257 arg1 = reinterpret_cast< wxMenu * >(argp1);
41258 ecode2 = SWIG_AsVal_int(obj1, &val2);
41259 if (!SWIG_IsOK(ecode2)) {
41260 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
41261 }
41262 arg2 = static_cast< int >(val2);
41263 {
41264 PyThreadState* __tstate = wxPyBeginAllowThreads();
41265 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
41266 wxPyEndAllowThreads(__tstate);
41267 if (PyErr_Occurred()) SWIG_fail;
41268 }
41269 {
41270 #if wxUSE_UNICODE
41271 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41272 #else
41273 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41274 #endif
41275 }
41276 return resultobj;
41277 fail:
41278 return NULL;
41279 }
41280
41281
41282 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41283 PyObject *resultobj = 0;
41284 wxMenu *arg1 = (wxMenu *) 0 ;
41285 wxString *arg2 = 0 ;
41286 void *argp1 = 0 ;
41287 int res1 = 0 ;
41288 bool temp2 = false ;
41289 PyObject * obj0 = 0 ;
41290 PyObject * obj1 = 0 ;
41291 char * kwnames[] = {
41292 (char *) "self",(char *) "title", NULL
41293 };
41294
41295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
41296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41297 if (!SWIG_IsOK(res1)) {
41298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
41299 }
41300 arg1 = reinterpret_cast< wxMenu * >(argp1);
41301 {
41302 arg2 = wxString_in_helper(obj1);
41303 if (arg2 == NULL) SWIG_fail;
41304 temp2 = true;
41305 }
41306 {
41307 PyThreadState* __tstate = wxPyBeginAllowThreads();
41308 (arg1)->SetTitle((wxString const &)*arg2);
41309 wxPyEndAllowThreads(__tstate);
41310 if (PyErr_Occurred()) SWIG_fail;
41311 }
41312 resultobj = SWIG_Py_Void();
41313 {
41314 if (temp2)
41315 delete arg2;
41316 }
41317 return resultobj;
41318 fail:
41319 {
41320 if (temp2)
41321 delete arg2;
41322 }
41323 return NULL;
41324 }
41325
41326
41327 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41328 PyObject *resultobj = 0;
41329 wxMenu *arg1 = (wxMenu *) 0 ;
41330 wxString result;
41331 void *argp1 = 0 ;
41332 int res1 = 0 ;
41333 PyObject *swig_obj[1] ;
41334
41335 if (!args) SWIG_fail;
41336 swig_obj[0] = args;
41337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41338 if (!SWIG_IsOK(res1)) {
41339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
41340 }
41341 arg1 = reinterpret_cast< wxMenu * >(argp1);
41342 {
41343 PyThreadState* __tstate = wxPyBeginAllowThreads();
41344 result = ((wxMenu const *)arg1)->GetTitle();
41345 wxPyEndAllowThreads(__tstate);
41346 if (PyErr_Occurred()) SWIG_fail;
41347 }
41348 {
41349 #if wxUSE_UNICODE
41350 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41351 #else
41352 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41353 #endif
41354 }
41355 return resultobj;
41356 fail:
41357 return NULL;
41358 }
41359
41360
41361 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41362 PyObject *resultobj = 0;
41363 wxMenu *arg1 = (wxMenu *) 0 ;
41364 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
41365 void *argp1 = 0 ;
41366 int res1 = 0 ;
41367 void *argp2 = 0 ;
41368 int res2 = 0 ;
41369 PyObject * obj0 = 0 ;
41370 PyObject * obj1 = 0 ;
41371 char * kwnames[] = {
41372 (char *) "self",(char *) "handler", NULL
41373 };
41374
41375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
41376 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41377 if (!SWIG_IsOK(res1)) {
41378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
41379 }
41380 arg1 = reinterpret_cast< wxMenu * >(argp1);
41381 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
41382 if (!SWIG_IsOK(res2)) {
41383 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
41384 }
41385 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
41386 {
41387 PyThreadState* __tstate = wxPyBeginAllowThreads();
41388 (arg1)->SetEventHandler(arg2);
41389 wxPyEndAllowThreads(__tstate);
41390 if (PyErr_Occurred()) SWIG_fail;
41391 }
41392 resultobj = SWIG_Py_Void();
41393 return resultobj;
41394 fail:
41395 return NULL;
41396 }
41397
41398
41399 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41400 PyObject *resultobj = 0;
41401 wxMenu *arg1 = (wxMenu *) 0 ;
41402 wxEvtHandler *result = 0 ;
41403 void *argp1 = 0 ;
41404 int res1 = 0 ;
41405 PyObject *swig_obj[1] ;
41406
41407 if (!args) SWIG_fail;
41408 swig_obj[0] = args;
41409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41410 if (!SWIG_IsOK(res1)) {
41411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
41412 }
41413 arg1 = reinterpret_cast< wxMenu * >(argp1);
41414 {
41415 PyThreadState* __tstate = wxPyBeginAllowThreads();
41416 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
41417 wxPyEndAllowThreads(__tstate);
41418 if (PyErr_Occurred()) SWIG_fail;
41419 }
41420 {
41421 resultobj = wxPyMake_wxObject(result, 0);
41422 }
41423 return resultobj;
41424 fail:
41425 return NULL;
41426 }
41427
41428
41429 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41430 PyObject *resultobj = 0;
41431 wxMenu *arg1 = (wxMenu *) 0 ;
41432 wxWindow *arg2 = (wxWindow *) 0 ;
41433 void *argp1 = 0 ;
41434 int res1 = 0 ;
41435 void *argp2 = 0 ;
41436 int res2 = 0 ;
41437 PyObject * obj0 = 0 ;
41438 PyObject * obj1 = 0 ;
41439 char * kwnames[] = {
41440 (char *) "self",(char *) "win", NULL
41441 };
41442
41443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
41444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41445 if (!SWIG_IsOK(res1)) {
41446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
41447 }
41448 arg1 = reinterpret_cast< wxMenu * >(argp1);
41449 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41450 if (!SWIG_IsOK(res2)) {
41451 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
41452 }
41453 arg2 = reinterpret_cast< wxWindow * >(argp2);
41454 {
41455 PyThreadState* __tstate = wxPyBeginAllowThreads();
41456 (arg1)->SetInvokingWindow(arg2);
41457 wxPyEndAllowThreads(__tstate);
41458 if (PyErr_Occurred()) SWIG_fail;
41459 }
41460 resultobj = SWIG_Py_Void();
41461 return resultobj;
41462 fail:
41463 return NULL;
41464 }
41465
41466
41467 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41468 PyObject *resultobj = 0;
41469 wxMenu *arg1 = (wxMenu *) 0 ;
41470 wxWindow *result = 0 ;
41471 void *argp1 = 0 ;
41472 int res1 = 0 ;
41473 PyObject *swig_obj[1] ;
41474
41475 if (!args) SWIG_fail;
41476 swig_obj[0] = args;
41477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41478 if (!SWIG_IsOK(res1)) {
41479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
41480 }
41481 arg1 = reinterpret_cast< wxMenu * >(argp1);
41482 {
41483 PyThreadState* __tstate = wxPyBeginAllowThreads();
41484 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
41485 wxPyEndAllowThreads(__tstate);
41486 if (PyErr_Occurred()) SWIG_fail;
41487 }
41488 {
41489 resultobj = wxPyMake_wxObject(result, 0);
41490 }
41491 return resultobj;
41492 fail:
41493 return NULL;
41494 }
41495
41496
41497 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41498 PyObject *resultobj = 0;
41499 wxMenu *arg1 = (wxMenu *) 0 ;
41500 long result;
41501 void *argp1 = 0 ;
41502 int res1 = 0 ;
41503 PyObject *swig_obj[1] ;
41504
41505 if (!args) SWIG_fail;
41506 swig_obj[0] = args;
41507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41508 if (!SWIG_IsOK(res1)) {
41509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
41510 }
41511 arg1 = reinterpret_cast< wxMenu * >(argp1);
41512 {
41513 PyThreadState* __tstate = wxPyBeginAllowThreads();
41514 result = (long)((wxMenu const *)arg1)->GetStyle();
41515 wxPyEndAllowThreads(__tstate);
41516 if (PyErr_Occurred()) SWIG_fail;
41517 }
41518 resultobj = SWIG_From_long(static_cast< long >(result));
41519 return resultobj;
41520 fail:
41521 return NULL;
41522 }
41523
41524
41525 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41526 PyObject *resultobj = 0;
41527 wxMenu *arg1 = (wxMenu *) 0 ;
41528 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
41529 void *argp1 = 0 ;
41530 int res1 = 0 ;
41531 void *argp2 = 0 ;
41532 int res2 = 0 ;
41533 PyObject * obj0 = 0 ;
41534 PyObject * obj1 = 0 ;
41535 char * kwnames[] = {
41536 (char *) "self",(char *) "source", NULL
41537 };
41538
41539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
41540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41541 if (!SWIG_IsOK(res1)) {
41542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
41543 }
41544 arg1 = reinterpret_cast< wxMenu * >(argp1);
41545 if (obj1) {
41546 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
41547 if (!SWIG_IsOK(res2)) {
41548 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
41549 }
41550 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
41551 }
41552 {
41553 PyThreadState* __tstate = wxPyBeginAllowThreads();
41554 (arg1)->UpdateUI(arg2);
41555 wxPyEndAllowThreads(__tstate);
41556 if (PyErr_Occurred()) SWIG_fail;
41557 }
41558 resultobj = SWIG_Py_Void();
41559 return resultobj;
41560 fail:
41561 return NULL;
41562 }
41563
41564
41565 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41566 PyObject *resultobj = 0;
41567 wxMenu *arg1 = (wxMenu *) 0 ;
41568 wxMenuBar *result = 0 ;
41569 void *argp1 = 0 ;
41570 int res1 = 0 ;
41571 PyObject *swig_obj[1] ;
41572
41573 if (!args) SWIG_fail;
41574 swig_obj[0] = args;
41575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41576 if (!SWIG_IsOK(res1)) {
41577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
41578 }
41579 arg1 = reinterpret_cast< wxMenu * >(argp1);
41580 {
41581 PyThreadState* __tstate = wxPyBeginAllowThreads();
41582 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
41583 wxPyEndAllowThreads(__tstate);
41584 if (PyErr_Occurred()) SWIG_fail;
41585 }
41586 {
41587 resultobj = wxPyMake_wxObject(result, (bool)0);
41588 }
41589 return resultobj;
41590 fail:
41591 return NULL;
41592 }
41593
41594
41595 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41596 PyObject *resultobj = 0;
41597 wxMenu *arg1 = (wxMenu *) 0 ;
41598 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
41599 void *argp1 = 0 ;
41600 int res1 = 0 ;
41601 void *argp2 = 0 ;
41602 int res2 = 0 ;
41603 PyObject * obj0 = 0 ;
41604 PyObject * obj1 = 0 ;
41605 char * kwnames[] = {
41606 (char *) "self",(char *) "menubar", NULL
41607 };
41608
41609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
41610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41611 if (!SWIG_IsOK(res1)) {
41612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
41613 }
41614 arg1 = reinterpret_cast< wxMenu * >(argp1);
41615 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
41616 if (!SWIG_IsOK(res2)) {
41617 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
41618 }
41619 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
41620 {
41621 PyThreadState* __tstate = wxPyBeginAllowThreads();
41622 (arg1)->Attach(arg2);
41623 wxPyEndAllowThreads(__tstate);
41624 if (PyErr_Occurred()) SWIG_fail;
41625 }
41626 resultobj = SWIG_Py_Void();
41627 return resultobj;
41628 fail:
41629 return NULL;
41630 }
41631
41632
41633 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41634 PyObject *resultobj = 0;
41635 wxMenu *arg1 = (wxMenu *) 0 ;
41636 void *argp1 = 0 ;
41637 int res1 = 0 ;
41638 PyObject *swig_obj[1] ;
41639
41640 if (!args) SWIG_fail;
41641 swig_obj[0] = args;
41642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41643 if (!SWIG_IsOK(res1)) {
41644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
41645 }
41646 arg1 = reinterpret_cast< wxMenu * >(argp1);
41647 {
41648 PyThreadState* __tstate = wxPyBeginAllowThreads();
41649 (arg1)->Detach();
41650 wxPyEndAllowThreads(__tstate);
41651 if (PyErr_Occurred()) SWIG_fail;
41652 }
41653 resultobj = SWIG_Py_Void();
41654 return resultobj;
41655 fail:
41656 return NULL;
41657 }
41658
41659
41660 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41661 PyObject *resultobj = 0;
41662 wxMenu *arg1 = (wxMenu *) 0 ;
41663 bool result;
41664 void *argp1 = 0 ;
41665 int res1 = 0 ;
41666 PyObject *swig_obj[1] ;
41667
41668 if (!args) SWIG_fail;
41669 swig_obj[0] = args;
41670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41671 if (!SWIG_IsOK(res1)) {
41672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
41673 }
41674 arg1 = reinterpret_cast< wxMenu * >(argp1);
41675 {
41676 PyThreadState* __tstate = wxPyBeginAllowThreads();
41677 result = (bool)((wxMenu const *)arg1)->IsAttached();
41678 wxPyEndAllowThreads(__tstate);
41679 if (PyErr_Occurred()) SWIG_fail;
41680 }
41681 {
41682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41683 }
41684 return resultobj;
41685 fail:
41686 return NULL;
41687 }
41688
41689
41690 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41691 PyObject *resultobj = 0;
41692 wxMenu *arg1 = (wxMenu *) 0 ;
41693 wxMenu *arg2 = (wxMenu *) 0 ;
41694 void *argp1 = 0 ;
41695 int res1 = 0 ;
41696 void *argp2 = 0 ;
41697 int res2 = 0 ;
41698 PyObject * obj0 = 0 ;
41699 PyObject * obj1 = 0 ;
41700 char * kwnames[] = {
41701 (char *) "self",(char *) "parent", NULL
41702 };
41703
41704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
41705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41706 if (!SWIG_IsOK(res1)) {
41707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
41708 }
41709 arg1 = reinterpret_cast< wxMenu * >(argp1);
41710 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41711 if (!SWIG_IsOK(res2)) {
41712 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
41713 }
41714 arg2 = reinterpret_cast< wxMenu * >(argp2);
41715 {
41716 PyThreadState* __tstate = wxPyBeginAllowThreads();
41717 (arg1)->SetParent(arg2);
41718 wxPyEndAllowThreads(__tstate);
41719 if (PyErr_Occurred()) SWIG_fail;
41720 }
41721 resultobj = SWIG_Py_Void();
41722 return resultobj;
41723 fail:
41724 return NULL;
41725 }
41726
41727
41728 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41729 PyObject *resultobj = 0;
41730 wxMenu *arg1 = (wxMenu *) 0 ;
41731 wxMenu *result = 0 ;
41732 void *argp1 = 0 ;
41733 int res1 = 0 ;
41734 PyObject *swig_obj[1] ;
41735
41736 if (!args) SWIG_fail;
41737 swig_obj[0] = args;
41738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41739 if (!SWIG_IsOK(res1)) {
41740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
41741 }
41742 arg1 = reinterpret_cast< wxMenu * >(argp1);
41743 {
41744 PyThreadState* __tstate = wxPyBeginAllowThreads();
41745 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
41746 wxPyEndAllowThreads(__tstate);
41747 if (PyErr_Occurred()) SWIG_fail;
41748 }
41749 {
41750 resultobj = wxPyMake_wxObject(result, 0);
41751 }
41752 return resultobj;
41753 fail:
41754 return NULL;
41755 }
41756
41757
41758 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41759 PyObject *obj;
41760 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41761 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
41762 return SWIG_Py_Void();
41763 }
41764
41765 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41766 return SWIG_Python_InitShadowInstance(args);
41767 }
41768
41769 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41770 PyObject *resultobj = 0;
41771 long arg1 = (long) 0 ;
41772 wxMenuBar *result = 0 ;
41773 long val1 ;
41774 int ecode1 = 0 ;
41775 PyObject * obj0 = 0 ;
41776 char * kwnames[] = {
41777 (char *) "style", NULL
41778 };
41779
41780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
41781 if (obj0) {
41782 ecode1 = SWIG_AsVal_long(obj0, &val1);
41783 if (!SWIG_IsOK(ecode1)) {
41784 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
41785 }
41786 arg1 = static_cast< long >(val1);
41787 }
41788 {
41789 if (!wxPyCheckForApp()) SWIG_fail;
41790 PyThreadState* __tstate = wxPyBeginAllowThreads();
41791 result = (wxMenuBar *)new wxMenuBar(arg1);
41792 wxPyEndAllowThreads(__tstate);
41793 if (PyErr_Occurred()) SWIG_fail;
41794 }
41795 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
41796 return resultobj;
41797 fail:
41798 return NULL;
41799 }
41800
41801
41802 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41803 PyObject *resultobj = 0;
41804 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41805 wxMenu *arg2 = (wxMenu *) 0 ;
41806 wxString *arg3 = 0 ;
41807 bool result;
41808 void *argp1 = 0 ;
41809 int res1 = 0 ;
41810 void *argp2 = 0 ;
41811 int res2 = 0 ;
41812 bool temp3 = false ;
41813 PyObject * obj0 = 0 ;
41814 PyObject * obj1 = 0 ;
41815 PyObject * obj2 = 0 ;
41816 char * kwnames[] = {
41817 (char *) "self",(char *) "menu",(char *) "title", NULL
41818 };
41819
41820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41822 if (!SWIG_IsOK(res1)) {
41823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41824 }
41825 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41826 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41827 if (!SWIG_IsOK(res2)) {
41828 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
41829 }
41830 arg2 = reinterpret_cast< wxMenu * >(argp2);
41831 {
41832 arg3 = wxString_in_helper(obj2);
41833 if (arg3 == NULL) SWIG_fail;
41834 temp3 = true;
41835 }
41836 {
41837 PyThreadState* __tstate = wxPyBeginAllowThreads();
41838 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
41839 wxPyEndAllowThreads(__tstate);
41840 if (PyErr_Occurred()) SWIG_fail;
41841 }
41842 {
41843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41844 }
41845 {
41846 if (temp3)
41847 delete arg3;
41848 }
41849 return resultobj;
41850 fail:
41851 {
41852 if (temp3)
41853 delete arg3;
41854 }
41855 return NULL;
41856 }
41857
41858
41859 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41860 PyObject *resultobj = 0;
41861 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41862 size_t arg2 ;
41863 wxMenu *arg3 = (wxMenu *) 0 ;
41864 wxString *arg4 = 0 ;
41865 bool result;
41866 void *argp1 = 0 ;
41867 int res1 = 0 ;
41868 size_t val2 ;
41869 int ecode2 = 0 ;
41870 void *argp3 = 0 ;
41871 int res3 = 0 ;
41872 bool temp4 = false ;
41873 PyObject * obj0 = 0 ;
41874 PyObject * obj1 = 0 ;
41875 PyObject * obj2 = 0 ;
41876 PyObject * obj3 = 0 ;
41877 char * kwnames[] = {
41878 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41879 };
41880
41881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41883 if (!SWIG_IsOK(res1)) {
41884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41885 }
41886 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41887 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41888 if (!SWIG_IsOK(ecode2)) {
41889 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
41890 }
41891 arg2 = static_cast< size_t >(val2);
41892 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41893 if (!SWIG_IsOK(res3)) {
41894 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
41895 }
41896 arg3 = reinterpret_cast< wxMenu * >(argp3);
41897 {
41898 arg4 = wxString_in_helper(obj3);
41899 if (arg4 == NULL) SWIG_fail;
41900 temp4 = true;
41901 }
41902 {
41903 PyThreadState* __tstate = wxPyBeginAllowThreads();
41904 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
41905 wxPyEndAllowThreads(__tstate);
41906 if (PyErr_Occurred()) SWIG_fail;
41907 }
41908 {
41909 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41910 }
41911 {
41912 if (temp4)
41913 delete arg4;
41914 }
41915 return resultobj;
41916 fail:
41917 {
41918 if (temp4)
41919 delete arg4;
41920 }
41921 return NULL;
41922 }
41923
41924
41925 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41926 PyObject *resultobj = 0;
41927 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41928 size_t result;
41929 void *argp1 = 0 ;
41930 int res1 = 0 ;
41931 PyObject *swig_obj[1] ;
41932
41933 if (!args) SWIG_fail;
41934 swig_obj[0] = args;
41935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41936 if (!SWIG_IsOK(res1)) {
41937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41938 }
41939 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41940 {
41941 PyThreadState* __tstate = wxPyBeginAllowThreads();
41942 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
41943 wxPyEndAllowThreads(__tstate);
41944 if (PyErr_Occurred()) SWIG_fail;
41945 }
41946 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
41947 return resultobj;
41948 fail:
41949 return NULL;
41950 }
41951
41952
41953 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41954 PyObject *resultobj = 0;
41955 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41956 size_t arg2 ;
41957 wxMenu *result = 0 ;
41958 void *argp1 = 0 ;
41959 int res1 = 0 ;
41960 size_t val2 ;
41961 int ecode2 = 0 ;
41962 PyObject * obj0 = 0 ;
41963 PyObject * obj1 = 0 ;
41964 char * kwnames[] = {
41965 (char *) "self",(char *) "pos", NULL
41966 };
41967
41968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41970 if (!SWIG_IsOK(res1)) {
41971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41972 }
41973 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41974 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41975 if (!SWIG_IsOK(ecode2)) {
41976 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
41977 }
41978 arg2 = static_cast< size_t >(val2);
41979 {
41980 PyThreadState* __tstate = wxPyBeginAllowThreads();
41981 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
41982 wxPyEndAllowThreads(__tstate);
41983 if (PyErr_Occurred()) SWIG_fail;
41984 }
41985 {
41986 resultobj = wxPyMake_wxObject(result, 0);
41987 }
41988 return resultobj;
41989 fail:
41990 return NULL;
41991 }
41992
41993
41994 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41995 PyObject *resultobj = 0;
41996 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41997 size_t arg2 ;
41998 wxMenu *arg3 = (wxMenu *) 0 ;
41999 wxString *arg4 = 0 ;
42000 wxMenu *result = 0 ;
42001 void *argp1 = 0 ;
42002 int res1 = 0 ;
42003 size_t val2 ;
42004 int ecode2 = 0 ;
42005 void *argp3 = 0 ;
42006 int res3 = 0 ;
42007 bool temp4 = false ;
42008 PyObject * obj0 = 0 ;
42009 PyObject * obj1 = 0 ;
42010 PyObject * obj2 = 0 ;
42011 PyObject * obj3 = 0 ;
42012 char * kwnames[] = {
42013 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
42014 };
42015
42016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42018 if (!SWIG_IsOK(res1)) {
42019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42020 }
42021 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42022 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42023 if (!SWIG_IsOK(ecode2)) {
42024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
42025 }
42026 arg2 = static_cast< size_t >(val2);
42027 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
42028 if (!SWIG_IsOK(res3)) {
42029 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
42030 }
42031 arg3 = reinterpret_cast< wxMenu * >(argp3);
42032 {
42033 arg4 = wxString_in_helper(obj3);
42034 if (arg4 == NULL) SWIG_fail;
42035 temp4 = true;
42036 }
42037 {
42038 PyThreadState* __tstate = wxPyBeginAllowThreads();
42039 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
42040 wxPyEndAllowThreads(__tstate);
42041 if (PyErr_Occurred()) SWIG_fail;
42042 }
42043 {
42044 resultobj = wxPyMake_wxObject(result, 0);
42045 }
42046 {
42047 if (temp4)
42048 delete arg4;
42049 }
42050 return resultobj;
42051 fail:
42052 {
42053 if (temp4)
42054 delete arg4;
42055 }
42056 return NULL;
42057 }
42058
42059
42060 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42061 PyObject *resultobj = 0;
42062 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42063 size_t arg2 ;
42064 wxMenu *result = 0 ;
42065 void *argp1 = 0 ;
42066 int res1 = 0 ;
42067 size_t val2 ;
42068 int ecode2 = 0 ;
42069 PyObject * obj0 = 0 ;
42070 PyObject * obj1 = 0 ;
42071 char * kwnames[] = {
42072 (char *) "self",(char *) "pos", NULL
42073 };
42074
42075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
42076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42077 if (!SWIG_IsOK(res1)) {
42078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42079 }
42080 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42081 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42082 if (!SWIG_IsOK(ecode2)) {
42083 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
42084 }
42085 arg2 = static_cast< size_t >(val2);
42086 {
42087 PyThreadState* __tstate = wxPyBeginAllowThreads();
42088 result = (wxMenu *)(arg1)->Remove(arg2);
42089 wxPyEndAllowThreads(__tstate);
42090 if (PyErr_Occurred()) SWIG_fail;
42091 }
42092 {
42093 resultobj = wxPyMake_wxObject(result, 0);
42094 }
42095 return resultobj;
42096 fail:
42097 return NULL;
42098 }
42099
42100
42101 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42102 PyObject *resultobj = 0;
42103 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42104 size_t arg2 ;
42105 bool arg3 ;
42106 void *argp1 = 0 ;
42107 int res1 = 0 ;
42108 size_t val2 ;
42109 int ecode2 = 0 ;
42110 bool val3 ;
42111 int ecode3 = 0 ;
42112 PyObject * obj0 = 0 ;
42113 PyObject * obj1 = 0 ;
42114 PyObject * obj2 = 0 ;
42115 char * kwnames[] = {
42116 (char *) "self",(char *) "pos",(char *) "enable", NULL
42117 };
42118
42119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42121 if (!SWIG_IsOK(res1)) {
42122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42123 }
42124 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42125 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42126 if (!SWIG_IsOK(ecode2)) {
42127 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
42128 }
42129 arg2 = static_cast< size_t >(val2);
42130 ecode3 = SWIG_AsVal_bool(obj2, &val3);
42131 if (!SWIG_IsOK(ecode3)) {
42132 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
42133 }
42134 arg3 = static_cast< bool >(val3);
42135 {
42136 PyThreadState* __tstate = wxPyBeginAllowThreads();
42137 (arg1)->EnableTop(arg2,arg3);
42138 wxPyEndAllowThreads(__tstate);
42139 if (PyErr_Occurred()) SWIG_fail;
42140 }
42141 resultobj = SWIG_Py_Void();
42142 return resultobj;
42143 fail:
42144 return NULL;
42145 }
42146
42147
42148 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42149 PyObject *resultobj = 0;
42150 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42151 size_t arg2 ;
42152 bool result;
42153 void *argp1 = 0 ;
42154 int res1 = 0 ;
42155 size_t val2 ;
42156 int ecode2 = 0 ;
42157 PyObject * obj0 = 0 ;
42158 PyObject * obj1 = 0 ;
42159 char * kwnames[] = {
42160 (char *) "self",(char *) "pos", NULL
42161 };
42162
42163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
42164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42165 if (!SWIG_IsOK(res1)) {
42166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42167 }
42168 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42169 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42170 if (!SWIG_IsOK(ecode2)) {
42171 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
42172 }
42173 arg2 = static_cast< size_t >(val2);
42174 {
42175 PyThreadState* __tstate = wxPyBeginAllowThreads();
42176 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
42177 wxPyEndAllowThreads(__tstate);
42178 if (PyErr_Occurred()) SWIG_fail;
42179 }
42180 {
42181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42182 }
42183 return resultobj;
42184 fail:
42185 return NULL;
42186 }
42187
42188
42189 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42190 PyObject *resultobj = 0;
42191 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42192 size_t arg2 ;
42193 wxString *arg3 = 0 ;
42194 void *argp1 = 0 ;
42195 int res1 = 0 ;
42196 size_t val2 ;
42197 int ecode2 = 0 ;
42198 bool temp3 = false ;
42199 PyObject * obj0 = 0 ;
42200 PyObject * obj1 = 0 ;
42201 PyObject * obj2 = 0 ;
42202 char * kwnames[] = {
42203 (char *) "self",(char *) "pos",(char *) "label", NULL
42204 };
42205
42206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42208 if (!SWIG_IsOK(res1)) {
42209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42210 }
42211 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42212 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42213 if (!SWIG_IsOK(ecode2)) {
42214 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
42215 }
42216 arg2 = static_cast< size_t >(val2);
42217 {
42218 arg3 = wxString_in_helper(obj2);
42219 if (arg3 == NULL) SWIG_fail;
42220 temp3 = true;
42221 }
42222 {
42223 PyThreadState* __tstate = wxPyBeginAllowThreads();
42224 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
42225 wxPyEndAllowThreads(__tstate);
42226 if (PyErr_Occurred()) SWIG_fail;
42227 }
42228 resultobj = SWIG_Py_Void();
42229 {
42230 if (temp3)
42231 delete arg3;
42232 }
42233 return resultobj;
42234 fail:
42235 {
42236 if (temp3)
42237 delete arg3;
42238 }
42239 return NULL;
42240 }
42241
42242
42243 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42244 PyObject *resultobj = 0;
42245 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42246 size_t arg2 ;
42247 wxString result;
42248 void *argp1 = 0 ;
42249 int res1 = 0 ;
42250 size_t val2 ;
42251 int ecode2 = 0 ;
42252 PyObject * obj0 = 0 ;
42253 PyObject * obj1 = 0 ;
42254 char * kwnames[] = {
42255 (char *) "self",(char *) "pos", NULL
42256 };
42257
42258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
42259 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42260 if (!SWIG_IsOK(res1)) {
42261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42262 }
42263 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42264 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42265 if (!SWIG_IsOK(ecode2)) {
42266 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
42267 }
42268 arg2 = static_cast< size_t >(val2);
42269 {
42270 PyThreadState* __tstate = wxPyBeginAllowThreads();
42271 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
42272 wxPyEndAllowThreads(__tstate);
42273 if (PyErr_Occurred()) SWIG_fail;
42274 }
42275 {
42276 #if wxUSE_UNICODE
42277 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42278 #else
42279 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42280 #endif
42281 }
42282 return resultobj;
42283 fail:
42284 return NULL;
42285 }
42286
42287
42288 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42289 PyObject *resultobj = 0;
42290 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42291 wxString *arg2 = 0 ;
42292 wxString *arg3 = 0 ;
42293 int result;
42294 void *argp1 = 0 ;
42295 int res1 = 0 ;
42296 bool temp2 = false ;
42297 bool temp3 = false ;
42298 PyObject * obj0 = 0 ;
42299 PyObject * obj1 = 0 ;
42300 PyObject * obj2 = 0 ;
42301 char * kwnames[] = {
42302 (char *) "self",(char *) "menu",(char *) "item", NULL
42303 };
42304
42305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42307 if (!SWIG_IsOK(res1)) {
42308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42309 }
42310 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42311 {
42312 arg2 = wxString_in_helper(obj1);
42313 if (arg2 == NULL) SWIG_fail;
42314 temp2 = true;
42315 }
42316 {
42317 arg3 = wxString_in_helper(obj2);
42318 if (arg3 == NULL) SWIG_fail;
42319 temp3 = true;
42320 }
42321 {
42322 PyThreadState* __tstate = wxPyBeginAllowThreads();
42323 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
42324 wxPyEndAllowThreads(__tstate);
42325 if (PyErr_Occurred()) SWIG_fail;
42326 }
42327 resultobj = SWIG_From_int(static_cast< int >(result));
42328 {
42329 if (temp2)
42330 delete arg2;
42331 }
42332 {
42333 if (temp3)
42334 delete arg3;
42335 }
42336 return resultobj;
42337 fail:
42338 {
42339 if (temp2)
42340 delete arg2;
42341 }
42342 {
42343 if (temp3)
42344 delete arg3;
42345 }
42346 return NULL;
42347 }
42348
42349
42350 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42351 PyObject *resultobj = 0;
42352 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42353 int arg2 ;
42354 wxMenuItem *result = 0 ;
42355 void *argp1 = 0 ;
42356 int res1 = 0 ;
42357 int val2 ;
42358 int ecode2 = 0 ;
42359 PyObject * obj0 = 0 ;
42360 PyObject * obj1 = 0 ;
42361 char * kwnames[] = {
42362 (char *) "self",(char *) "id", NULL
42363 };
42364
42365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
42366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42367 if (!SWIG_IsOK(res1)) {
42368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42369 }
42370 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42371 ecode2 = SWIG_AsVal_int(obj1, &val2);
42372 if (!SWIG_IsOK(ecode2)) {
42373 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
42374 }
42375 arg2 = static_cast< int >(val2);
42376 {
42377 PyThreadState* __tstate = wxPyBeginAllowThreads();
42378 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
42379 wxPyEndAllowThreads(__tstate);
42380 if (PyErr_Occurred()) SWIG_fail;
42381 }
42382 {
42383 resultobj = wxPyMake_wxObject(result, (bool)0);
42384 }
42385 return resultobj;
42386 fail:
42387 return NULL;
42388 }
42389
42390
42391 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42392 PyObject *resultobj = 0;
42393 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42394 wxString *arg2 = 0 ;
42395 int result;
42396 void *argp1 = 0 ;
42397 int res1 = 0 ;
42398 bool temp2 = false ;
42399 PyObject * obj0 = 0 ;
42400 PyObject * obj1 = 0 ;
42401 char * kwnames[] = {
42402 (char *) "self",(char *) "title", NULL
42403 };
42404
42405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42406 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42407 if (!SWIG_IsOK(res1)) {
42408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42409 }
42410 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42411 {
42412 arg2 = wxString_in_helper(obj1);
42413 if (arg2 == NULL) SWIG_fail;
42414 temp2 = true;
42415 }
42416 {
42417 PyThreadState* __tstate = wxPyBeginAllowThreads();
42418 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
42419 wxPyEndAllowThreads(__tstate);
42420 if (PyErr_Occurred()) SWIG_fail;
42421 }
42422 resultobj = SWIG_From_int(static_cast< int >(result));
42423 {
42424 if (temp2)
42425 delete arg2;
42426 }
42427 return resultobj;
42428 fail:
42429 {
42430 if (temp2)
42431 delete arg2;
42432 }
42433 return NULL;
42434 }
42435
42436
42437 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42438 PyObject *resultobj = 0;
42439 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42440 int arg2 ;
42441 bool arg3 ;
42442 void *argp1 = 0 ;
42443 int res1 = 0 ;
42444 int val2 ;
42445 int ecode2 = 0 ;
42446 bool val3 ;
42447 int ecode3 = 0 ;
42448 PyObject * obj0 = 0 ;
42449 PyObject * obj1 = 0 ;
42450 PyObject * obj2 = 0 ;
42451 char * kwnames[] = {
42452 (char *) "self",(char *) "id",(char *) "enable", NULL
42453 };
42454
42455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42457 if (!SWIG_IsOK(res1)) {
42458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42459 }
42460 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42461 ecode2 = SWIG_AsVal_int(obj1, &val2);
42462 if (!SWIG_IsOK(ecode2)) {
42463 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
42464 }
42465 arg2 = static_cast< int >(val2);
42466 ecode3 = SWIG_AsVal_bool(obj2, &val3);
42467 if (!SWIG_IsOK(ecode3)) {
42468 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
42469 }
42470 arg3 = static_cast< bool >(val3);
42471 {
42472 PyThreadState* __tstate = wxPyBeginAllowThreads();
42473 (arg1)->Enable(arg2,arg3);
42474 wxPyEndAllowThreads(__tstate);
42475 if (PyErr_Occurred()) SWIG_fail;
42476 }
42477 resultobj = SWIG_Py_Void();
42478 return resultobj;
42479 fail:
42480 return NULL;
42481 }
42482
42483
42484 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42485 PyObject *resultobj = 0;
42486 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42487 int arg2 ;
42488 bool arg3 ;
42489 void *argp1 = 0 ;
42490 int res1 = 0 ;
42491 int val2 ;
42492 int ecode2 = 0 ;
42493 bool val3 ;
42494 int ecode3 = 0 ;
42495 PyObject * obj0 = 0 ;
42496 PyObject * obj1 = 0 ;
42497 PyObject * obj2 = 0 ;
42498 char * kwnames[] = {
42499 (char *) "self",(char *) "id",(char *) "check", NULL
42500 };
42501
42502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42504 if (!SWIG_IsOK(res1)) {
42505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42506 }
42507 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42508 ecode2 = SWIG_AsVal_int(obj1, &val2);
42509 if (!SWIG_IsOK(ecode2)) {
42510 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
42511 }
42512 arg2 = static_cast< int >(val2);
42513 ecode3 = SWIG_AsVal_bool(obj2, &val3);
42514 if (!SWIG_IsOK(ecode3)) {
42515 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
42516 }
42517 arg3 = static_cast< bool >(val3);
42518 {
42519 PyThreadState* __tstate = wxPyBeginAllowThreads();
42520 (arg1)->Check(arg2,arg3);
42521 wxPyEndAllowThreads(__tstate);
42522 if (PyErr_Occurred()) SWIG_fail;
42523 }
42524 resultobj = SWIG_Py_Void();
42525 return resultobj;
42526 fail:
42527 return NULL;
42528 }
42529
42530
42531 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42532 PyObject *resultobj = 0;
42533 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42534 int arg2 ;
42535 bool result;
42536 void *argp1 = 0 ;
42537 int res1 = 0 ;
42538 int val2 ;
42539 int ecode2 = 0 ;
42540 PyObject * obj0 = 0 ;
42541 PyObject * obj1 = 0 ;
42542 char * kwnames[] = {
42543 (char *) "self",(char *) "id", NULL
42544 };
42545
42546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
42547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42548 if (!SWIG_IsOK(res1)) {
42549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42550 }
42551 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42552 ecode2 = SWIG_AsVal_int(obj1, &val2);
42553 if (!SWIG_IsOK(ecode2)) {
42554 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
42555 }
42556 arg2 = static_cast< int >(val2);
42557 {
42558 PyThreadState* __tstate = wxPyBeginAllowThreads();
42559 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
42560 wxPyEndAllowThreads(__tstate);
42561 if (PyErr_Occurred()) SWIG_fail;
42562 }
42563 {
42564 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42565 }
42566 return resultobj;
42567 fail:
42568 return NULL;
42569 }
42570
42571
42572 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42573 PyObject *resultobj = 0;
42574 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42575 int arg2 ;
42576 bool result;
42577 void *argp1 = 0 ;
42578 int res1 = 0 ;
42579 int val2 ;
42580 int ecode2 = 0 ;
42581 PyObject * obj0 = 0 ;
42582 PyObject * obj1 = 0 ;
42583 char * kwnames[] = {
42584 (char *) "self",(char *) "id", NULL
42585 };
42586
42587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
42588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42589 if (!SWIG_IsOK(res1)) {
42590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42591 }
42592 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42593 ecode2 = SWIG_AsVal_int(obj1, &val2);
42594 if (!SWIG_IsOK(ecode2)) {
42595 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
42596 }
42597 arg2 = static_cast< int >(val2);
42598 {
42599 PyThreadState* __tstate = wxPyBeginAllowThreads();
42600 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
42601 wxPyEndAllowThreads(__tstate);
42602 if (PyErr_Occurred()) SWIG_fail;
42603 }
42604 {
42605 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42606 }
42607 return resultobj;
42608 fail:
42609 return NULL;
42610 }
42611
42612
42613 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42614 PyObject *resultobj = 0;
42615 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42616 int arg2 ;
42617 wxString *arg3 = 0 ;
42618 void *argp1 = 0 ;
42619 int res1 = 0 ;
42620 int val2 ;
42621 int ecode2 = 0 ;
42622 bool temp3 = false ;
42623 PyObject * obj0 = 0 ;
42624 PyObject * obj1 = 0 ;
42625 PyObject * obj2 = 0 ;
42626 char * kwnames[] = {
42627 (char *) "self",(char *) "id",(char *) "label", NULL
42628 };
42629
42630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42632 if (!SWIG_IsOK(res1)) {
42633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42634 }
42635 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42636 ecode2 = SWIG_AsVal_int(obj1, &val2);
42637 if (!SWIG_IsOK(ecode2)) {
42638 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
42639 }
42640 arg2 = static_cast< int >(val2);
42641 {
42642 arg3 = wxString_in_helper(obj2);
42643 if (arg3 == NULL) SWIG_fail;
42644 temp3 = true;
42645 }
42646 {
42647 PyThreadState* __tstate = wxPyBeginAllowThreads();
42648 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
42649 wxPyEndAllowThreads(__tstate);
42650 if (PyErr_Occurred()) SWIG_fail;
42651 }
42652 resultobj = SWIG_Py_Void();
42653 {
42654 if (temp3)
42655 delete arg3;
42656 }
42657 return resultobj;
42658 fail:
42659 {
42660 if (temp3)
42661 delete arg3;
42662 }
42663 return NULL;
42664 }
42665
42666
42667 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42668 PyObject *resultobj = 0;
42669 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42670 int arg2 ;
42671 wxString result;
42672 void *argp1 = 0 ;
42673 int res1 = 0 ;
42674 int val2 ;
42675 int ecode2 = 0 ;
42676 PyObject * obj0 = 0 ;
42677 PyObject * obj1 = 0 ;
42678 char * kwnames[] = {
42679 (char *) "self",(char *) "id", NULL
42680 };
42681
42682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
42683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42684 if (!SWIG_IsOK(res1)) {
42685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42686 }
42687 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42688 ecode2 = SWIG_AsVal_int(obj1, &val2);
42689 if (!SWIG_IsOK(ecode2)) {
42690 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
42691 }
42692 arg2 = static_cast< int >(val2);
42693 {
42694 PyThreadState* __tstate = wxPyBeginAllowThreads();
42695 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
42696 wxPyEndAllowThreads(__tstate);
42697 if (PyErr_Occurred()) SWIG_fail;
42698 }
42699 {
42700 #if wxUSE_UNICODE
42701 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42702 #else
42703 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42704 #endif
42705 }
42706 return resultobj;
42707 fail:
42708 return NULL;
42709 }
42710
42711
42712 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42713 PyObject *resultobj = 0;
42714 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42715 int arg2 ;
42716 wxString *arg3 = 0 ;
42717 void *argp1 = 0 ;
42718 int res1 = 0 ;
42719 int val2 ;
42720 int ecode2 = 0 ;
42721 bool temp3 = false ;
42722 PyObject * obj0 = 0 ;
42723 PyObject * obj1 = 0 ;
42724 PyObject * obj2 = 0 ;
42725 char * kwnames[] = {
42726 (char *) "self",(char *) "id",(char *) "helpString", NULL
42727 };
42728
42729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42731 if (!SWIG_IsOK(res1)) {
42732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42733 }
42734 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42735 ecode2 = SWIG_AsVal_int(obj1, &val2);
42736 if (!SWIG_IsOK(ecode2)) {
42737 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
42738 }
42739 arg2 = static_cast< int >(val2);
42740 {
42741 arg3 = wxString_in_helper(obj2);
42742 if (arg3 == NULL) SWIG_fail;
42743 temp3 = true;
42744 }
42745 {
42746 PyThreadState* __tstate = wxPyBeginAllowThreads();
42747 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
42748 wxPyEndAllowThreads(__tstate);
42749 if (PyErr_Occurred()) SWIG_fail;
42750 }
42751 resultobj = SWIG_Py_Void();
42752 {
42753 if (temp3)
42754 delete arg3;
42755 }
42756 return resultobj;
42757 fail:
42758 {
42759 if (temp3)
42760 delete arg3;
42761 }
42762 return NULL;
42763 }
42764
42765
42766 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42767 PyObject *resultobj = 0;
42768 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42769 int arg2 ;
42770 wxString result;
42771 void *argp1 = 0 ;
42772 int res1 = 0 ;
42773 int val2 ;
42774 int ecode2 = 0 ;
42775 PyObject * obj0 = 0 ;
42776 PyObject * obj1 = 0 ;
42777 char * kwnames[] = {
42778 (char *) "self",(char *) "id", NULL
42779 };
42780
42781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
42782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42783 if (!SWIG_IsOK(res1)) {
42784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42785 }
42786 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42787 ecode2 = SWIG_AsVal_int(obj1, &val2);
42788 if (!SWIG_IsOK(ecode2)) {
42789 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
42790 }
42791 arg2 = static_cast< int >(val2);
42792 {
42793 PyThreadState* __tstate = wxPyBeginAllowThreads();
42794 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
42795 wxPyEndAllowThreads(__tstate);
42796 if (PyErr_Occurred()) SWIG_fail;
42797 }
42798 {
42799 #if wxUSE_UNICODE
42800 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42801 #else
42802 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42803 #endif
42804 }
42805 return resultobj;
42806 fail:
42807 return NULL;
42808 }
42809
42810
42811 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42812 PyObject *resultobj = 0;
42813 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42814 wxFrame *result = 0 ;
42815 void *argp1 = 0 ;
42816 int res1 = 0 ;
42817 PyObject *swig_obj[1] ;
42818
42819 if (!args) SWIG_fail;
42820 swig_obj[0] = args;
42821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42822 if (!SWIG_IsOK(res1)) {
42823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42824 }
42825 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42826 {
42827 PyThreadState* __tstate = wxPyBeginAllowThreads();
42828 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
42829 wxPyEndAllowThreads(__tstate);
42830 if (PyErr_Occurred()) SWIG_fail;
42831 }
42832 {
42833 resultobj = wxPyMake_wxObject(result, (bool)0);
42834 }
42835 return resultobj;
42836 fail:
42837 return NULL;
42838 }
42839
42840
42841 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42842 PyObject *resultobj = 0;
42843 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42844 bool result;
42845 void *argp1 = 0 ;
42846 int res1 = 0 ;
42847 PyObject *swig_obj[1] ;
42848
42849 if (!args) SWIG_fail;
42850 swig_obj[0] = args;
42851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42852 if (!SWIG_IsOK(res1)) {
42853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42854 }
42855 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42856 {
42857 PyThreadState* __tstate = wxPyBeginAllowThreads();
42858 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
42859 wxPyEndAllowThreads(__tstate);
42860 if (PyErr_Occurred()) SWIG_fail;
42861 }
42862 {
42863 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42864 }
42865 return resultobj;
42866 fail:
42867 return NULL;
42868 }
42869
42870
42871 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42872 PyObject *resultobj = 0;
42873 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42874 wxFrame *arg2 = (wxFrame *) 0 ;
42875 void *argp1 = 0 ;
42876 int res1 = 0 ;
42877 void *argp2 = 0 ;
42878 int res2 = 0 ;
42879 PyObject * obj0 = 0 ;
42880 PyObject * obj1 = 0 ;
42881 char * kwnames[] = {
42882 (char *) "self",(char *) "frame", NULL
42883 };
42884
42885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
42886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42887 if (!SWIG_IsOK(res1)) {
42888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42889 }
42890 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42891 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
42892 if (!SWIG_IsOK(res2)) {
42893 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
42894 }
42895 arg2 = reinterpret_cast< wxFrame * >(argp2);
42896 {
42897 PyThreadState* __tstate = wxPyBeginAllowThreads();
42898 (arg1)->Attach(arg2);
42899 wxPyEndAllowThreads(__tstate);
42900 if (PyErr_Occurred()) SWIG_fail;
42901 }
42902 resultobj = SWIG_Py_Void();
42903 return resultobj;
42904 fail:
42905 return NULL;
42906 }
42907
42908
42909 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42910 PyObject *resultobj = 0;
42911 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42912 void *argp1 = 0 ;
42913 int res1 = 0 ;
42914 PyObject *swig_obj[1] ;
42915
42916 if (!args) SWIG_fail;
42917 swig_obj[0] = args;
42918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42919 if (!SWIG_IsOK(res1)) {
42920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42921 }
42922 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42923 {
42924 PyThreadState* __tstate = wxPyBeginAllowThreads();
42925 (arg1)->Detach();
42926 wxPyEndAllowThreads(__tstate);
42927 if (PyErr_Occurred()) SWIG_fail;
42928 }
42929 resultobj = SWIG_Py_Void();
42930 return resultobj;
42931 fail:
42932 return NULL;
42933 }
42934
42935
42936 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42937 PyObject *resultobj = 0;
42938 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42939 void *argp1 = 0 ;
42940 int res1 = 0 ;
42941 PyObject *swig_obj[1] ;
42942
42943 if (!args) SWIG_fail;
42944 swig_obj[0] = args;
42945 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42946 if (!SWIG_IsOK(res1)) {
42947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42948 }
42949 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42950 {
42951 PyThreadState* __tstate = wxPyBeginAllowThreads();
42952 (arg1)->UpdateMenus();
42953 wxPyEndAllowThreads(__tstate);
42954 if (PyErr_Occurred()) SWIG_fail;
42955 }
42956 resultobj = SWIG_Py_Void();
42957 return resultobj;
42958 fail:
42959 return NULL;
42960 }
42961
42962
42963 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42964 PyObject *resultobj = 0;
42965 bool arg1 ;
42966 bool val1 ;
42967 int ecode1 = 0 ;
42968 PyObject * obj0 = 0 ;
42969 char * kwnames[] = {
42970 (char *) "enable", NULL
42971 };
42972
42973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
42974 ecode1 = SWIG_AsVal_bool(obj0, &val1);
42975 if (!SWIG_IsOK(ecode1)) {
42976 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
42977 }
42978 arg1 = static_cast< bool >(val1);
42979 {
42980 PyThreadState* __tstate = wxPyBeginAllowThreads();
42981 wxMenuBar::SetAutoWindowMenu(arg1);
42982 wxPyEndAllowThreads(__tstate);
42983 if (PyErr_Occurred()) SWIG_fail;
42984 }
42985 resultobj = SWIG_Py_Void();
42986 return resultobj;
42987 fail:
42988 return NULL;
42989 }
42990
42991
42992 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42993 PyObject *resultobj = 0;
42994 bool result;
42995
42996 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
42997 {
42998 PyThreadState* __tstate = wxPyBeginAllowThreads();
42999 result = (bool)wxMenuBar::GetAutoWindowMenu();
43000 wxPyEndAllowThreads(__tstate);
43001 if (PyErr_Occurred()) SWIG_fail;
43002 }
43003 {
43004 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43005 }
43006 return resultobj;
43007 fail:
43008 return NULL;
43009 }
43010
43011
43012 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43013 PyObject *obj;
43014 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43015 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
43016 return SWIG_Py_Void();
43017 }
43018
43019 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43020 return SWIG_Python_InitShadowInstance(args);
43021 }
43022
43023 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43024 PyObject *resultobj = 0;
43025 wxMenu *arg1 = (wxMenu *) NULL ;
43026 int arg2 = (int) wxID_ANY ;
43027 wxString const &arg3_defvalue = wxPyEmptyString ;
43028 wxString *arg3 = (wxString *) &arg3_defvalue ;
43029 wxString const &arg4_defvalue = wxPyEmptyString ;
43030 wxString *arg4 = (wxString *) &arg4_defvalue ;
43031 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
43032 wxMenu *arg6 = (wxMenu *) NULL ;
43033 wxMenuItem *result = 0 ;
43034 void *argp1 = 0 ;
43035 int res1 = 0 ;
43036 int val2 ;
43037 int ecode2 = 0 ;
43038 bool temp3 = false ;
43039 bool temp4 = false ;
43040 int val5 ;
43041 int ecode5 = 0 ;
43042 void *argp6 = 0 ;
43043 int res6 = 0 ;
43044 PyObject * obj0 = 0 ;
43045 PyObject * obj1 = 0 ;
43046 PyObject * obj2 = 0 ;
43047 PyObject * obj3 = 0 ;
43048 PyObject * obj4 = 0 ;
43049 PyObject * obj5 = 0 ;
43050 char * kwnames[] = {
43051 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
43052 };
43053
43054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
43055 if (obj0) {
43056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43057 if (!SWIG_IsOK(res1)) {
43058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43059 }
43060 arg1 = reinterpret_cast< wxMenu * >(argp1);
43061 }
43062 if (obj1) {
43063 ecode2 = SWIG_AsVal_int(obj1, &val2);
43064 if (!SWIG_IsOK(ecode2)) {
43065 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
43066 }
43067 arg2 = static_cast< int >(val2);
43068 }
43069 if (obj2) {
43070 {
43071 arg3 = wxString_in_helper(obj2);
43072 if (arg3 == NULL) SWIG_fail;
43073 temp3 = true;
43074 }
43075 }
43076 if (obj3) {
43077 {
43078 arg4 = wxString_in_helper(obj3);
43079 if (arg4 == NULL) SWIG_fail;
43080 temp4 = true;
43081 }
43082 }
43083 if (obj4) {
43084 ecode5 = SWIG_AsVal_int(obj4, &val5);
43085 if (!SWIG_IsOK(ecode5)) {
43086 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
43087 }
43088 arg5 = static_cast< wxItemKind >(val5);
43089 }
43090 if (obj5) {
43091 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
43092 if (!SWIG_IsOK(res6)) {
43093 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
43094 }
43095 arg6 = reinterpret_cast< wxMenu * >(argp6);
43096 }
43097 {
43098 PyThreadState* __tstate = wxPyBeginAllowThreads();
43099 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
43100 wxPyEndAllowThreads(__tstate);
43101 if (PyErr_Occurred()) SWIG_fail;
43102 }
43103 {
43104 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
43105 }
43106 {
43107 if (temp3)
43108 delete arg3;
43109 }
43110 {
43111 if (temp4)
43112 delete arg4;
43113 }
43114 return resultobj;
43115 fail:
43116 {
43117 if (temp3)
43118 delete arg3;
43119 }
43120 {
43121 if (temp4)
43122 delete arg4;
43123 }
43124 return NULL;
43125 }
43126
43127
43128 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43129 PyObject *resultobj = 0;
43130 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43131 void *argp1 = 0 ;
43132 int res1 = 0 ;
43133 PyObject *swig_obj[1] ;
43134
43135 if (!args) SWIG_fail;
43136 swig_obj[0] = args;
43137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
43138 if (!SWIG_IsOK(res1)) {
43139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43140 }
43141 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43142 {
43143 PyThreadState* __tstate = wxPyBeginAllowThreads();
43144 delete arg1;
43145
43146 wxPyEndAllowThreads(__tstate);
43147 if (PyErr_Occurred()) SWIG_fail;
43148 }
43149 resultobj = SWIG_Py_Void();
43150 return resultobj;
43151 fail:
43152 return NULL;
43153 }
43154
43155
43156 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43157 PyObject *resultobj = 0;
43158 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43159 wxMenu *result = 0 ;
43160 void *argp1 = 0 ;
43161 int res1 = 0 ;
43162 PyObject *swig_obj[1] ;
43163
43164 if (!args) SWIG_fail;
43165 swig_obj[0] = args;
43166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43167 if (!SWIG_IsOK(res1)) {
43168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43169 }
43170 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43171 {
43172 PyThreadState* __tstate = wxPyBeginAllowThreads();
43173 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
43174 wxPyEndAllowThreads(__tstate);
43175 if (PyErr_Occurred()) SWIG_fail;
43176 }
43177 {
43178 resultobj = wxPyMake_wxObject(result, 0);
43179 }
43180 return resultobj;
43181 fail:
43182 return NULL;
43183 }
43184
43185
43186 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43187 PyObject *resultobj = 0;
43188 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43189 wxMenu *arg2 = (wxMenu *) 0 ;
43190 void *argp1 = 0 ;
43191 int res1 = 0 ;
43192 void *argp2 = 0 ;
43193 int res2 = 0 ;
43194 PyObject * obj0 = 0 ;
43195 PyObject * obj1 = 0 ;
43196 char * kwnames[] = {
43197 (char *) "self",(char *) "menu", NULL
43198 };
43199
43200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
43201 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43202 if (!SWIG_IsOK(res1)) {
43203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43204 }
43205 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43206 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
43207 if (!SWIG_IsOK(res2)) {
43208 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
43209 }
43210 arg2 = reinterpret_cast< wxMenu * >(argp2);
43211 {
43212 PyThreadState* __tstate = wxPyBeginAllowThreads();
43213 (arg1)->SetMenu(arg2);
43214 wxPyEndAllowThreads(__tstate);
43215 if (PyErr_Occurred()) SWIG_fail;
43216 }
43217 resultobj = SWIG_Py_Void();
43218 return resultobj;
43219 fail:
43220 return NULL;
43221 }
43222
43223
43224 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43225 PyObject *resultobj = 0;
43226 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43227 int arg2 ;
43228 void *argp1 = 0 ;
43229 int res1 = 0 ;
43230 int val2 ;
43231 int ecode2 = 0 ;
43232 PyObject * obj0 = 0 ;
43233 PyObject * obj1 = 0 ;
43234 char * kwnames[] = {
43235 (char *) "self",(char *) "id", NULL
43236 };
43237
43238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
43239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43240 if (!SWIG_IsOK(res1)) {
43241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43242 }
43243 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43244 ecode2 = SWIG_AsVal_int(obj1, &val2);
43245 if (!SWIG_IsOK(ecode2)) {
43246 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
43247 }
43248 arg2 = static_cast< int >(val2);
43249 {
43250 PyThreadState* __tstate = wxPyBeginAllowThreads();
43251 (arg1)->SetId(arg2);
43252 wxPyEndAllowThreads(__tstate);
43253 if (PyErr_Occurred()) SWIG_fail;
43254 }
43255 resultobj = SWIG_Py_Void();
43256 return resultobj;
43257 fail:
43258 return NULL;
43259 }
43260
43261
43262 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43263 PyObject *resultobj = 0;
43264 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43265 int result;
43266 void *argp1 = 0 ;
43267 int res1 = 0 ;
43268 PyObject *swig_obj[1] ;
43269
43270 if (!args) SWIG_fail;
43271 swig_obj[0] = args;
43272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43273 if (!SWIG_IsOK(res1)) {
43274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43275 }
43276 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43277 {
43278 PyThreadState* __tstate = wxPyBeginAllowThreads();
43279 result = (int)((wxMenuItem const *)arg1)->GetId();
43280 wxPyEndAllowThreads(__tstate);
43281 if (PyErr_Occurred()) SWIG_fail;
43282 }
43283 resultobj = SWIG_From_int(static_cast< int >(result));
43284 return resultobj;
43285 fail:
43286 return NULL;
43287 }
43288
43289
43290 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43291 PyObject *resultobj = 0;
43292 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43293 bool result;
43294 void *argp1 = 0 ;
43295 int res1 = 0 ;
43296 PyObject *swig_obj[1] ;
43297
43298 if (!args) SWIG_fail;
43299 swig_obj[0] = args;
43300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43301 if (!SWIG_IsOK(res1)) {
43302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43303 }
43304 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43305 {
43306 PyThreadState* __tstate = wxPyBeginAllowThreads();
43307 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
43308 wxPyEndAllowThreads(__tstate);
43309 if (PyErr_Occurred()) SWIG_fail;
43310 }
43311 {
43312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43313 }
43314 return resultobj;
43315 fail:
43316 return NULL;
43317 }
43318
43319
43320 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43321 PyObject *resultobj = 0;
43322 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43323 wxString *arg2 = 0 ;
43324 void *argp1 = 0 ;
43325 int res1 = 0 ;
43326 bool temp2 = false ;
43327 PyObject * obj0 = 0 ;
43328 PyObject * obj1 = 0 ;
43329 char * kwnames[] = {
43330 (char *) "self",(char *) "str", NULL
43331 };
43332
43333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
43334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43335 if (!SWIG_IsOK(res1)) {
43336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43337 }
43338 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43339 {
43340 arg2 = wxString_in_helper(obj1);
43341 if (arg2 == NULL) SWIG_fail;
43342 temp2 = true;
43343 }
43344 {
43345 PyThreadState* __tstate = wxPyBeginAllowThreads();
43346 (arg1)->SetText((wxString const &)*arg2);
43347 wxPyEndAllowThreads(__tstate);
43348 if (PyErr_Occurred()) SWIG_fail;
43349 }
43350 resultobj = SWIG_Py_Void();
43351 {
43352 if (temp2)
43353 delete arg2;
43354 }
43355 return resultobj;
43356 fail:
43357 {
43358 if (temp2)
43359 delete arg2;
43360 }
43361 return NULL;
43362 }
43363
43364
43365 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43366 PyObject *resultobj = 0;
43367 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43368 wxString result;
43369 void *argp1 = 0 ;
43370 int res1 = 0 ;
43371 PyObject *swig_obj[1] ;
43372
43373 if (!args) SWIG_fail;
43374 swig_obj[0] = args;
43375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43376 if (!SWIG_IsOK(res1)) {
43377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43378 }
43379 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43380 {
43381 PyThreadState* __tstate = wxPyBeginAllowThreads();
43382 result = ((wxMenuItem const *)arg1)->GetLabel();
43383 wxPyEndAllowThreads(__tstate);
43384 if (PyErr_Occurred()) SWIG_fail;
43385 }
43386 {
43387 #if wxUSE_UNICODE
43388 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43389 #else
43390 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43391 #endif
43392 }
43393 return resultobj;
43394 fail:
43395 return NULL;
43396 }
43397
43398
43399 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43400 PyObject *resultobj = 0;
43401 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43402 wxString *result = 0 ;
43403 void *argp1 = 0 ;
43404 int res1 = 0 ;
43405 PyObject *swig_obj[1] ;
43406
43407 if (!args) SWIG_fail;
43408 swig_obj[0] = args;
43409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43410 if (!SWIG_IsOK(res1)) {
43411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43412 }
43413 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43414 {
43415 PyThreadState* __tstate = wxPyBeginAllowThreads();
43416 {
43417 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
43418 result = (wxString *) &_result_ref;
43419 }
43420 wxPyEndAllowThreads(__tstate);
43421 if (PyErr_Occurred()) SWIG_fail;
43422 }
43423 {
43424 #if wxUSE_UNICODE
43425 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43426 #else
43427 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43428 #endif
43429 }
43430 return resultobj;
43431 fail:
43432 return NULL;
43433 }
43434
43435
43436 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43437 PyObject *resultobj = 0;
43438 wxString *arg1 = 0 ;
43439 wxString result;
43440 bool temp1 = false ;
43441 PyObject * obj0 = 0 ;
43442 char * kwnames[] = {
43443 (char *) "text", NULL
43444 };
43445
43446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
43447 {
43448 arg1 = wxString_in_helper(obj0);
43449 if (arg1 == NULL) SWIG_fail;
43450 temp1 = true;
43451 }
43452 {
43453 PyThreadState* __tstate = wxPyBeginAllowThreads();
43454 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
43455 wxPyEndAllowThreads(__tstate);
43456 if (PyErr_Occurred()) SWIG_fail;
43457 }
43458 {
43459 #if wxUSE_UNICODE
43460 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43461 #else
43462 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43463 #endif
43464 }
43465 {
43466 if (temp1)
43467 delete arg1;
43468 }
43469 return resultobj;
43470 fail:
43471 {
43472 if (temp1)
43473 delete arg1;
43474 }
43475 return NULL;
43476 }
43477
43478
43479 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43480 PyObject *resultobj = 0;
43481 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43482 wxItemKind result;
43483 void *argp1 = 0 ;
43484 int res1 = 0 ;
43485 PyObject *swig_obj[1] ;
43486
43487 if (!args) SWIG_fail;
43488 swig_obj[0] = args;
43489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43490 if (!SWIG_IsOK(res1)) {
43491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43492 }
43493 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43494 {
43495 PyThreadState* __tstate = wxPyBeginAllowThreads();
43496 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
43497 wxPyEndAllowThreads(__tstate);
43498 if (PyErr_Occurred()) SWIG_fail;
43499 }
43500 resultobj = SWIG_From_int(static_cast< int >(result));
43501 return resultobj;
43502 fail:
43503 return NULL;
43504 }
43505
43506
43507 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43508 PyObject *resultobj = 0;
43509 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43510 wxItemKind arg2 ;
43511 void *argp1 = 0 ;
43512 int res1 = 0 ;
43513 int val2 ;
43514 int ecode2 = 0 ;
43515 PyObject * obj0 = 0 ;
43516 PyObject * obj1 = 0 ;
43517 char * kwnames[] = {
43518 (char *) "self",(char *) "kind", NULL
43519 };
43520
43521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
43522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43523 if (!SWIG_IsOK(res1)) {
43524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43525 }
43526 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43527 ecode2 = SWIG_AsVal_int(obj1, &val2);
43528 if (!SWIG_IsOK(ecode2)) {
43529 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
43530 }
43531 arg2 = static_cast< wxItemKind >(val2);
43532 {
43533 PyThreadState* __tstate = wxPyBeginAllowThreads();
43534 (arg1)->SetKind(arg2);
43535 wxPyEndAllowThreads(__tstate);
43536 if (PyErr_Occurred()) SWIG_fail;
43537 }
43538 resultobj = SWIG_Py_Void();
43539 return resultobj;
43540 fail:
43541 return NULL;
43542 }
43543
43544
43545 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43546 PyObject *resultobj = 0;
43547 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43548 bool arg2 ;
43549 void *argp1 = 0 ;
43550 int res1 = 0 ;
43551 bool val2 ;
43552 int ecode2 = 0 ;
43553 PyObject * obj0 = 0 ;
43554 PyObject * obj1 = 0 ;
43555 char * kwnames[] = {
43556 (char *) "self",(char *) "checkable", NULL
43557 };
43558
43559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
43560 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43561 if (!SWIG_IsOK(res1)) {
43562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43563 }
43564 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43565 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43566 if (!SWIG_IsOK(ecode2)) {
43567 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
43568 }
43569 arg2 = static_cast< bool >(val2);
43570 {
43571 PyThreadState* __tstate = wxPyBeginAllowThreads();
43572 (arg1)->SetCheckable(arg2);
43573 wxPyEndAllowThreads(__tstate);
43574 if (PyErr_Occurred()) SWIG_fail;
43575 }
43576 resultobj = SWIG_Py_Void();
43577 return resultobj;
43578 fail:
43579 return NULL;
43580 }
43581
43582
43583 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43584 PyObject *resultobj = 0;
43585 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43586 bool result;
43587 void *argp1 = 0 ;
43588 int res1 = 0 ;
43589 PyObject *swig_obj[1] ;
43590
43591 if (!args) SWIG_fail;
43592 swig_obj[0] = args;
43593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43594 if (!SWIG_IsOK(res1)) {
43595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43596 }
43597 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43598 {
43599 PyThreadState* __tstate = wxPyBeginAllowThreads();
43600 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
43601 wxPyEndAllowThreads(__tstate);
43602 if (PyErr_Occurred()) SWIG_fail;
43603 }
43604 {
43605 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43606 }
43607 return resultobj;
43608 fail:
43609 return NULL;
43610 }
43611
43612
43613 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43614 PyObject *resultobj = 0;
43615 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43616 bool result;
43617 void *argp1 = 0 ;
43618 int res1 = 0 ;
43619 PyObject *swig_obj[1] ;
43620
43621 if (!args) SWIG_fail;
43622 swig_obj[0] = args;
43623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43624 if (!SWIG_IsOK(res1)) {
43625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43626 }
43627 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43628 {
43629 PyThreadState* __tstate = wxPyBeginAllowThreads();
43630 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
43631 wxPyEndAllowThreads(__tstate);
43632 if (PyErr_Occurred()) SWIG_fail;
43633 }
43634 {
43635 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43636 }
43637 return resultobj;
43638 fail:
43639 return NULL;
43640 }
43641
43642
43643 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43644 PyObject *resultobj = 0;
43645 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43646 wxMenu *arg2 = (wxMenu *) 0 ;
43647 void *argp1 = 0 ;
43648 int res1 = 0 ;
43649 void *argp2 = 0 ;
43650 int res2 = 0 ;
43651 PyObject * obj0 = 0 ;
43652 PyObject * obj1 = 0 ;
43653 char * kwnames[] = {
43654 (char *) "self",(char *) "menu", NULL
43655 };
43656
43657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
43658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43659 if (!SWIG_IsOK(res1)) {
43660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43661 }
43662 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43663 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
43664 if (!SWIG_IsOK(res2)) {
43665 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
43666 }
43667 arg2 = reinterpret_cast< wxMenu * >(argp2);
43668 {
43669 PyThreadState* __tstate = wxPyBeginAllowThreads();
43670 (arg1)->SetSubMenu(arg2);
43671 wxPyEndAllowThreads(__tstate);
43672 if (PyErr_Occurred()) SWIG_fail;
43673 }
43674 resultobj = SWIG_Py_Void();
43675 return resultobj;
43676 fail:
43677 return NULL;
43678 }
43679
43680
43681 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43682 PyObject *resultobj = 0;
43683 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43684 wxMenu *result = 0 ;
43685 void *argp1 = 0 ;
43686 int res1 = 0 ;
43687 PyObject *swig_obj[1] ;
43688
43689 if (!args) SWIG_fail;
43690 swig_obj[0] = args;
43691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43692 if (!SWIG_IsOK(res1)) {
43693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43694 }
43695 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43696 {
43697 PyThreadState* __tstate = wxPyBeginAllowThreads();
43698 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
43699 wxPyEndAllowThreads(__tstate);
43700 if (PyErr_Occurred()) SWIG_fail;
43701 }
43702 {
43703 resultobj = wxPyMake_wxObject(result, 0);
43704 }
43705 return resultobj;
43706 fail:
43707 return NULL;
43708 }
43709
43710
43711 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43712 PyObject *resultobj = 0;
43713 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43714 bool arg2 = (bool) true ;
43715 void *argp1 = 0 ;
43716 int res1 = 0 ;
43717 bool val2 ;
43718 int ecode2 = 0 ;
43719 PyObject * obj0 = 0 ;
43720 PyObject * obj1 = 0 ;
43721 char * kwnames[] = {
43722 (char *) "self",(char *) "enable", NULL
43723 };
43724
43725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
43726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43727 if (!SWIG_IsOK(res1)) {
43728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43729 }
43730 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43731 if (obj1) {
43732 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43733 if (!SWIG_IsOK(ecode2)) {
43734 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
43735 }
43736 arg2 = static_cast< bool >(val2);
43737 }
43738 {
43739 PyThreadState* __tstate = wxPyBeginAllowThreads();
43740 (arg1)->Enable(arg2);
43741 wxPyEndAllowThreads(__tstate);
43742 if (PyErr_Occurred()) SWIG_fail;
43743 }
43744 resultobj = SWIG_Py_Void();
43745 return resultobj;
43746 fail:
43747 return NULL;
43748 }
43749
43750
43751 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43752 PyObject *resultobj = 0;
43753 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43754 bool result;
43755 void *argp1 = 0 ;
43756 int res1 = 0 ;
43757 PyObject *swig_obj[1] ;
43758
43759 if (!args) SWIG_fail;
43760 swig_obj[0] = args;
43761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43762 if (!SWIG_IsOK(res1)) {
43763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43764 }
43765 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43766 {
43767 PyThreadState* __tstate = wxPyBeginAllowThreads();
43768 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
43769 wxPyEndAllowThreads(__tstate);
43770 if (PyErr_Occurred()) SWIG_fail;
43771 }
43772 {
43773 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43774 }
43775 return resultobj;
43776 fail:
43777 return NULL;
43778 }
43779
43780
43781 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43782 PyObject *resultobj = 0;
43783 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43784 bool arg2 = (bool) true ;
43785 void *argp1 = 0 ;
43786 int res1 = 0 ;
43787 bool val2 ;
43788 int ecode2 = 0 ;
43789 PyObject * obj0 = 0 ;
43790 PyObject * obj1 = 0 ;
43791 char * kwnames[] = {
43792 (char *) "self",(char *) "check", NULL
43793 };
43794
43795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
43796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43797 if (!SWIG_IsOK(res1)) {
43798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43799 }
43800 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43801 if (obj1) {
43802 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43803 if (!SWIG_IsOK(ecode2)) {
43804 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
43805 }
43806 arg2 = static_cast< bool >(val2);
43807 }
43808 {
43809 PyThreadState* __tstate = wxPyBeginAllowThreads();
43810 (arg1)->Check(arg2);
43811 wxPyEndAllowThreads(__tstate);
43812 if (PyErr_Occurred()) SWIG_fail;
43813 }
43814 resultobj = SWIG_Py_Void();
43815 return resultobj;
43816 fail:
43817 return NULL;
43818 }
43819
43820
43821 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43822 PyObject *resultobj = 0;
43823 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43824 bool result;
43825 void *argp1 = 0 ;
43826 int res1 = 0 ;
43827 PyObject *swig_obj[1] ;
43828
43829 if (!args) SWIG_fail;
43830 swig_obj[0] = args;
43831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43832 if (!SWIG_IsOK(res1)) {
43833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43834 }
43835 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43836 {
43837 PyThreadState* __tstate = wxPyBeginAllowThreads();
43838 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
43839 wxPyEndAllowThreads(__tstate);
43840 if (PyErr_Occurred()) SWIG_fail;
43841 }
43842 {
43843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43844 }
43845 return resultobj;
43846 fail:
43847 return NULL;
43848 }
43849
43850
43851 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43852 PyObject *resultobj = 0;
43853 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43854 void *argp1 = 0 ;
43855 int res1 = 0 ;
43856 PyObject *swig_obj[1] ;
43857
43858 if (!args) SWIG_fail;
43859 swig_obj[0] = args;
43860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43861 if (!SWIG_IsOK(res1)) {
43862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43863 }
43864 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43865 {
43866 PyThreadState* __tstate = wxPyBeginAllowThreads();
43867 (arg1)->Toggle();
43868 wxPyEndAllowThreads(__tstate);
43869 if (PyErr_Occurred()) SWIG_fail;
43870 }
43871 resultobj = SWIG_Py_Void();
43872 return resultobj;
43873 fail:
43874 return NULL;
43875 }
43876
43877
43878 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43879 PyObject *resultobj = 0;
43880 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43881 wxString *arg2 = 0 ;
43882 void *argp1 = 0 ;
43883 int res1 = 0 ;
43884 bool temp2 = false ;
43885 PyObject * obj0 = 0 ;
43886 PyObject * obj1 = 0 ;
43887 char * kwnames[] = {
43888 (char *) "self",(char *) "str", NULL
43889 };
43890
43891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
43892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43893 if (!SWIG_IsOK(res1)) {
43894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43895 }
43896 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43897 {
43898 arg2 = wxString_in_helper(obj1);
43899 if (arg2 == NULL) SWIG_fail;
43900 temp2 = true;
43901 }
43902 {
43903 PyThreadState* __tstate = wxPyBeginAllowThreads();
43904 (arg1)->SetHelp((wxString const &)*arg2);
43905 wxPyEndAllowThreads(__tstate);
43906 if (PyErr_Occurred()) SWIG_fail;
43907 }
43908 resultobj = SWIG_Py_Void();
43909 {
43910 if (temp2)
43911 delete arg2;
43912 }
43913 return resultobj;
43914 fail:
43915 {
43916 if (temp2)
43917 delete arg2;
43918 }
43919 return NULL;
43920 }
43921
43922
43923 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43924 PyObject *resultobj = 0;
43925 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43926 wxString *result = 0 ;
43927 void *argp1 = 0 ;
43928 int res1 = 0 ;
43929 PyObject *swig_obj[1] ;
43930
43931 if (!args) SWIG_fail;
43932 swig_obj[0] = args;
43933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43934 if (!SWIG_IsOK(res1)) {
43935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43936 }
43937 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43938 {
43939 PyThreadState* __tstate = wxPyBeginAllowThreads();
43940 {
43941 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
43942 result = (wxString *) &_result_ref;
43943 }
43944 wxPyEndAllowThreads(__tstate);
43945 if (PyErr_Occurred()) SWIG_fail;
43946 }
43947 {
43948 #if wxUSE_UNICODE
43949 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43950 #else
43951 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43952 #endif
43953 }
43954 return resultobj;
43955 fail:
43956 return NULL;
43957 }
43958
43959
43960 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43961 PyObject *resultobj = 0;
43962 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43963 wxAcceleratorEntry *result = 0 ;
43964 void *argp1 = 0 ;
43965 int res1 = 0 ;
43966 PyObject *swig_obj[1] ;
43967
43968 if (!args) SWIG_fail;
43969 swig_obj[0] = args;
43970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43971 if (!SWIG_IsOK(res1)) {
43972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43973 }
43974 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43975 {
43976 PyThreadState* __tstate = wxPyBeginAllowThreads();
43977 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
43978 wxPyEndAllowThreads(__tstate);
43979 if (PyErr_Occurred()) SWIG_fail;
43980 }
43981 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43982 return resultobj;
43983 fail:
43984 return NULL;
43985 }
43986
43987
43988 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43989 PyObject *resultobj = 0;
43990 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43991 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
43992 void *argp1 = 0 ;
43993 int res1 = 0 ;
43994 void *argp2 = 0 ;
43995 int res2 = 0 ;
43996 PyObject * obj0 = 0 ;
43997 PyObject * obj1 = 0 ;
43998 char * kwnames[] = {
43999 (char *) "self",(char *) "accel", NULL
44000 };
44001
44002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
44003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44004 if (!SWIG_IsOK(res1)) {
44005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44006 }
44007 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44008 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
44009 if (!SWIG_IsOK(res2)) {
44010 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
44011 }
44012 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
44013 {
44014 PyThreadState* __tstate = wxPyBeginAllowThreads();
44015 (arg1)->SetAccel(arg2);
44016 wxPyEndAllowThreads(__tstate);
44017 if (PyErr_Occurred()) SWIG_fail;
44018 }
44019 resultobj = SWIG_Py_Void();
44020 return resultobj;
44021 fail:
44022 return NULL;
44023 }
44024
44025
44026 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44027 PyObject *resultobj = 0;
44028 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44029 wxBitmap *arg2 = 0 ;
44030 void *argp1 = 0 ;
44031 int res1 = 0 ;
44032 void *argp2 = 0 ;
44033 int res2 = 0 ;
44034 PyObject * obj0 = 0 ;
44035 PyObject * obj1 = 0 ;
44036 char * kwnames[] = {
44037 (char *) "self",(char *) "bitmap", NULL
44038 };
44039
44040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
44041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44042 if (!SWIG_IsOK(res1)) {
44043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44044 }
44045 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44046 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
44047 if (!SWIG_IsOK(res2)) {
44048 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44049 }
44050 if (!argp2) {
44051 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44052 }
44053 arg2 = reinterpret_cast< wxBitmap * >(argp2);
44054 {
44055 PyThreadState* __tstate = wxPyBeginAllowThreads();
44056 (arg1)->SetBitmap((wxBitmap const &)*arg2);
44057 wxPyEndAllowThreads(__tstate);
44058 if (PyErr_Occurred()) SWIG_fail;
44059 }
44060 resultobj = SWIG_Py_Void();
44061 return resultobj;
44062 fail:
44063 return NULL;
44064 }
44065
44066
44067 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44068 PyObject *resultobj = 0;
44069 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44070 wxBitmap *result = 0 ;
44071 void *argp1 = 0 ;
44072 int res1 = 0 ;
44073 PyObject *swig_obj[1] ;
44074
44075 if (!args) SWIG_fail;
44076 swig_obj[0] = args;
44077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44078 if (!SWIG_IsOK(res1)) {
44079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44080 }
44081 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44082 {
44083 PyThreadState* __tstate = wxPyBeginAllowThreads();
44084 {
44085 wxBitmap const &_result_ref = (arg1)->GetBitmap();
44086 result = (wxBitmap *) &_result_ref;
44087 }
44088 wxPyEndAllowThreads(__tstate);
44089 if (PyErr_Occurred()) SWIG_fail;
44090 }
44091 {
44092 wxBitmap* resultptr = new wxBitmap(*result);
44093 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
44094 }
44095 return resultobj;
44096 fail:
44097 return NULL;
44098 }
44099
44100
44101 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44102 PyObject *resultobj = 0;
44103 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44104 wxFont *arg2 = 0 ;
44105 void *argp1 = 0 ;
44106 int res1 = 0 ;
44107 void *argp2 = 0 ;
44108 int res2 = 0 ;
44109 PyObject * obj0 = 0 ;
44110 PyObject * obj1 = 0 ;
44111 char * kwnames[] = {
44112 (char *) "self",(char *) "font", NULL
44113 };
44114
44115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
44116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44117 if (!SWIG_IsOK(res1)) {
44118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44119 }
44120 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44121 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
44122 if (!SWIG_IsOK(res2)) {
44123 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
44124 }
44125 if (!argp2) {
44126 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
44127 }
44128 arg2 = reinterpret_cast< wxFont * >(argp2);
44129 {
44130 PyThreadState* __tstate = wxPyBeginAllowThreads();
44131 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
44132 wxPyEndAllowThreads(__tstate);
44133 if (PyErr_Occurred()) SWIG_fail;
44134 }
44135 resultobj = SWIG_Py_Void();
44136 return resultobj;
44137 fail:
44138 return NULL;
44139 }
44140
44141
44142 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44143 PyObject *resultobj = 0;
44144 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44145 wxFont result;
44146 void *argp1 = 0 ;
44147 int res1 = 0 ;
44148 PyObject *swig_obj[1] ;
44149
44150 if (!args) SWIG_fail;
44151 swig_obj[0] = args;
44152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44153 if (!SWIG_IsOK(res1)) {
44154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44155 }
44156 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44157 {
44158 PyThreadState* __tstate = wxPyBeginAllowThreads();
44159 result = wxMenuItem_GetFont(arg1);
44160 wxPyEndAllowThreads(__tstate);
44161 if (PyErr_Occurred()) SWIG_fail;
44162 }
44163 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
44164 return resultobj;
44165 fail:
44166 return NULL;
44167 }
44168
44169
44170 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44171 PyObject *resultobj = 0;
44172 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44173 wxColour *arg2 = 0 ;
44174 void *argp1 = 0 ;
44175 int res1 = 0 ;
44176 wxColour temp2 ;
44177 PyObject * obj0 = 0 ;
44178 PyObject * obj1 = 0 ;
44179 char * kwnames[] = {
44180 (char *) "self",(char *) "colText", NULL
44181 };
44182
44183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
44184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44185 if (!SWIG_IsOK(res1)) {
44186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44187 }
44188 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44189 {
44190 arg2 = &temp2;
44191 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
44192 }
44193 {
44194 PyThreadState* __tstate = wxPyBeginAllowThreads();
44195 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
44196 wxPyEndAllowThreads(__tstate);
44197 if (PyErr_Occurred()) SWIG_fail;
44198 }
44199 resultobj = SWIG_Py_Void();
44200 return resultobj;
44201 fail:
44202 return NULL;
44203 }
44204
44205
44206 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44207 PyObject *resultobj = 0;
44208 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44209 wxColour result;
44210 void *argp1 = 0 ;
44211 int res1 = 0 ;
44212 PyObject *swig_obj[1] ;
44213
44214 if (!args) SWIG_fail;
44215 swig_obj[0] = args;
44216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44217 if (!SWIG_IsOK(res1)) {
44218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44219 }
44220 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44221 {
44222 PyThreadState* __tstate = wxPyBeginAllowThreads();
44223 result = wxMenuItem_GetTextColour(arg1);
44224 wxPyEndAllowThreads(__tstate);
44225 if (PyErr_Occurred()) SWIG_fail;
44226 }
44227 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
44228 return resultobj;
44229 fail:
44230 return NULL;
44231 }
44232
44233
44234 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44235 PyObject *resultobj = 0;
44236 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44237 wxColour *arg2 = 0 ;
44238 void *argp1 = 0 ;
44239 int res1 = 0 ;
44240 wxColour temp2 ;
44241 PyObject * obj0 = 0 ;
44242 PyObject * obj1 = 0 ;
44243 char * kwnames[] = {
44244 (char *) "self",(char *) "colBack", NULL
44245 };
44246
44247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
44248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44249 if (!SWIG_IsOK(res1)) {
44250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44251 }
44252 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44253 {
44254 arg2 = &temp2;
44255 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
44256 }
44257 {
44258 PyThreadState* __tstate = wxPyBeginAllowThreads();
44259 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
44260 wxPyEndAllowThreads(__tstate);
44261 if (PyErr_Occurred()) SWIG_fail;
44262 }
44263 resultobj = SWIG_Py_Void();
44264 return resultobj;
44265 fail:
44266 return NULL;
44267 }
44268
44269
44270 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44271 PyObject *resultobj = 0;
44272 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44273 wxColour result;
44274 void *argp1 = 0 ;
44275 int res1 = 0 ;
44276 PyObject *swig_obj[1] ;
44277
44278 if (!args) SWIG_fail;
44279 swig_obj[0] = args;
44280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44281 if (!SWIG_IsOK(res1)) {
44282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44283 }
44284 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44285 {
44286 PyThreadState* __tstate = wxPyBeginAllowThreads();
44287 result = wxMenuItem_GetBackgroundColour(arg1);
44288 wxPyEndAllowThreads(__tstate);
44289 if (PyErr_Occurred()) SWIG_fail;
44290 }
44291 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
44292 return resultobj;
44293 fail:
44294 return NULL;
44295 }
44296
44297
44298 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44299 PyObject *resultobj = 0;
44300 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44301 wxBitmap *arg2 = 0 ;
44302 wxBitmap const &arg3_defvalue = wxNullBitmap ;
44303 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
44304 void *argp1 = 0 ;
44305 int res1 = 0 ;
44306 void *argp2 = 0 ;
44307 int res2 = 0 ;
44308 void *argp3 = 0 ;
44309 int res3 = 0 ;
44310 PyObject * obj0 = 0 ;
44311 PyObject * obj1 = 0 ;
44312 PyObject * obj2 = 0 ;
44313 char * kwnames[] = {
44314 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
44315 };
44316
44317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44319 if (!SWIG_IsOK(res1)) {
44320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44321 }
44322 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44323 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
44324 if (!SWIG_IsOK(res2)) {
44325 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44326 }
44327 if (!argp2) {
44328 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44329 }
44330 arg2 = reinterpret_cast< wxBitmap * >(argp2);
44331 if (obj2) {
44332 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
44333 if (!SWIG_IsOK(res3)) {
44334 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
44335 }
44336 if (!argp3) {
44337 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
44338 }
44339 arg3 = reinterpret_cast< wxBitmap * >(argp3);
44340 }
44341 {
44342 PyThreadState* __tstate = wxPyBeginAllowThreads();
44343 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
44344 wxPyEndAllowThreads(__tstate);
44345 if (PyErr_Occurred()) SWIG_fail;
44346 }
44347 resultobj = SWIG_Py_Void();
44348 return resultobj;
44349 fail:
44350 return NULL;
44351 }
44352
44353
44354 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44355 PyObject *resultobj = 0;
44356 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44357 wxBitmap *arg2 = 0 ;
44358 void *argp1 = 0 ;
44359 int res1 = 0 ;
44360 void *argp2 = 0 ;
44361 int res2 = 0 ;
44362 PyObject * obj0 = 0 ;
44363 PyObject * obj1 = 0 ;
44364 char * kwnames[] = {
44365 (char *) "self",(char *) "bmpDisabled", NULL
44366 };
44367
44368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
44369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44370 if (!SWIG_IsOK(res1)) {
44371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44372 }
44373 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44374 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
44375 if (!SWIG_IsOK(res2)) {
44376 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44377 }
44378 if (!argp2) {
44379 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44380 }
44381 arg2 = reinterpret_cast< wxBitmap * >(argp2);
44382 {
44383 PyThreadState* __tstate = wxPyBeginAllowThreads();
44384 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
44385 wxPyEndAllowThreads(__tstate);
44386 if (PyErr_Occurred()) SWIG_fail;
44387 }
44388 resultobj = SWIG_Py_Void();
44389 return resultobj;
44390 fail:
44391 return NULL;
44392 }
44393
44394
44395 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44396 PyObject *resultobj = 0;
44397 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44398 wxBitmap *result = 0 ;
44399 void *argp1 = 0 ;
44400 int res1 = 0 ;
44401 PyObject *swig_obj[1] ;
44402
44403 if (!args) SWIG_fail;
44404 swig_obj[0] = args;
44405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44406 if (!SWIG_IsOK(res1)) {
44407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44408 }
44409 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44410 {
44411 PyThreadState* __tstate = wxPyBeginAllowThreads();
44412 {
44413 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
44414 result = (wxBitmap *) &_result_ref;
44415 }
44416 wxPyEndAllowThreads(__tstate);
44417 if (PyErr_Occurred()) SWIG_fail;
44418 }
44419 {
44420 wxBitmap* resultptr = new wxBitmap(*result);
44421 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
44422 }
44423 return resultobj;
44424 fail:
44425 return NULL;
44426 }
44427
44428
44429 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44430 PyObject *resultobj = 0;
44431 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44432 int arg2 ;
44433 void *argp1 = 0 ;
44434 int res1 = 0 ;
44435 int val2 ;
44436 int ecode2 = 0 ;
44437 PyObject * obj0 = 0 ;
44438 PyObject * obj1 = 0 ;
44439 char * kwnames[] = {
44440 (char *) "self",(char *) "nWidth", NULL
44441 };
44442
44443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
44444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44445 if (!SWIG_IsOK(res1)) {
44446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44447 }
44448 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44449 ecode2 = SWIG_AsVal_int(obj1, &val2);
44450 if (!SWIG_IsOK(ecode2)) {
44451 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
44452 }
44453 arg2 = static_cast< int >(val2);
44454 {
44455 PyThreadState* __tstate = wxPyBeginAllowThreads();
44456 wxMenuItem_SetMarginWidth(arg1,arg2);
44457 wxPyEndAllowThreads(__tstate);
44458 if (PyErr_Occurred()) SWIG_fail;
44459 }
44460 resultobj = SWIG_Py_Void();
44461 return resultobj;
44462 fail:
44463 return NULL;
44464 }
44465
44466
44467 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44468 PyObject *resultobj = 0;
44469 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44470 int result;
44471 void *argp1 = 0 ;
44472 int res1 = 0 ;
44473 PyObject *swig_obj[1] ;
44474
44475 if (!args) SWIG_fail;
44476 swig_obj[0] = args;
44477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44478 if (!SWIG_IsOK(res1)) {
44479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44480 }
44481 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44482 {
44483 PyThreadState* __tstate = wxPyBeginAllowThreads();
44484 result = (int)wxMenuItem_GetMarginWidth(arg1);
44485 wxPyEndAllowThreads(__tstate);
44486 if (PyErr_Occurred()) SWIG_fail;
44487 }
44488 resultobj = SWIG_From_int(static_cast< int >(result));
44489 return resultobj;
44490 fail:
44491 return NULL;
44492 }
44493
44494
44495 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44496 PyObject *resultobj = 0;
44497 int result;
44498
44499 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
44500 {
44501 PyThreadState* __tstate = wxPyBeginAllowThreads();
44502 result = (int)wxMenuItem_GetDefaultMarginWidth();
44503 wxPyEndAllowThreads(__tstate);
44504 if (PyErr_Occurred()) SWIG_fail;
44505 }
44506 resultobj = SWIG_From_int(static_cast< int >(result));
44507 return resultobj;
44508 fail:
44509 return NULL;
44510 }
44511
44512
44513 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44514 PyObject *resultobj = 0;
44515 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44516 bool result;
44517 void *argp1 = 0 ;
44518 int res1 = 0 ;
44519 PyObject *swig_obj[1] ;
44520
44521 if (!args) SWIG_fail;
44522 swig_obj[0] = args;
44523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44524 if (!SWIG_IsOK(res1)) {
44525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44526 }
44527 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44528 {
44529 PyThreadState* __tstate = wxPyBeginAllowThreads();
44530 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
44531 wxPyEndAllowThreads(__tstate);
44532 if (PyErr_Occurred()) SWIG_fail;
44533 }
44534 {
44535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44536 }
44537 return resultobj;
44538 fail:
44539 return NULL;
44540 }
44541
44542
44543 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44544 PyObject *resultobj = 0;
44545 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44546 bool arg2 = (bool) true ;
44547 void *argp1 = 0 ;
44548 int res1 = 0 ;
44549 bool val2 ;
44550 int ecode2 = 0 ;
44551 PyObject * obj0 = 0 ;
44552 PyObject * obj1 = 0 ;
44553 char * kwnames[] = {
44554 (char *) "self",(char *) "ownerDrawn", NULL
44555 };
44556
44557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
44558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44559 if (!SWIG_IsOK(res1)) {
44560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44561 }
44562 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44563 if (obj1) {
44564 ecode2 = SWIG_AsVal_bool(obj1, &val2);
44565 if (!SWIG_IsOK(ecode2)) {
44566 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
44567 }
44568 arg2 = static_cast< bool >(val2);
44569 }
44570 {
44571 PyThreadState* __tstate = wxPyBeginAllowThreads();
44572 wxMenuItem_SetOwnerDrawn(arg1,arg2);
44573 wxPyEndAllowThreads(__tstate);
44574 if (PyErr_Occurred()) SWIG_fail;
44575 }
44576 resultobj = SWIG_Py_Void();
44577 return resultobj;
44578 fail:
44579 return NULL;
44580 }
44581
44582
44583 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44584 PyObject *resultobj = 0;
44585 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44586 void *argp1 = 0 ;
44587 int res1 = 0 ;
44588 PyObject *swig_obj[1] ;
44589
44590 if (!args) SWIG_fail;
44591 swig_obj[0] = args;
44592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44593 if (!SWIG_IsOK(res1)) {
44594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44595 }
44596 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44597 {
44598 PyThreadState* __tstate = wxPyBeginAllowThreads();
44599 wxMenuItem_ResetOwnerDrawn(arg1);
44600 wxPyEndAllowThreads(__tstate);
44601 if (PyErr_Occurred()) SWIG_fail;
44602 }
44603 resultobj = SWIG_Py_Void();
44604 return resultobj;
44605 fail:
44606 return NULL;
44607 }
44608
44609
44610 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44611 PyObject *obj;
44612 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44613 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
44614 return SWIG_Py_Void();
44615 }
44616
44617 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44618 return SWIG_Python_InitShadowInstance(args);
44619 }
44620
44621 SWIGINTERN int ControlNameStr_set(PyObject *) {
44622 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
44623 return 1;
44624 }
44625
44626
44627 SWIGINTERN PyObject *ControlNameStr_get(void) {
44628 PyObject *pyobj = 0;
44629
44630 {
44631 #if wxUSE_UNICODE
44632 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
44633 #else
44634 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
44635 #endif
44636 }
44637 return pyobj;
44638 }
44639
44640
44641 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44642 PyObject *resultobj = 0;
44643 wxWindow *arg1 = (wxWindow *) 0 ;
44644 int arg2 = (int) -1 ;
44645 wxPoint const &arg3_defvalue = wxDefaultPosition ;
44646 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
44647 wxSize const &arg4_defvalue = wxDefaultSize ;
44648 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
44649 long arg5 = (long) 0 ;
44650 wxValidator const &arg6_defvalue = wxDefaultValidator ;
44651 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
44652 wxString const &arg7_defvalue = wxPyControlNameStr ;
44653 wxString *arg7 = (wxString *) &arg7_defvalue ;
44654 wxControl *result = 0 ;
44655 void *argp1 = 0 ;
44656 int res1 = 0 ;
44657 int val2 ;
44658 int ecode2 = 0 ;
44659 wxPoint temp3 ;
44660 wxSize temp4 ;
44661 long val5 ;
44662 int ecode5 = 0 ;
44663 void *argp6 = 0 ;
44664 int res6 = 0 ;
44665 bool temp7 = false ;
44666 PyObject * obj0 = 0 ;
44667 PyObject * obj1 = 0 ;
44668 PyObject * obj2 = 0 ;
44669 PyObject * obj3 = 0 ;
44670 PyObject * obj4 = 0 ;
44671 PyObject * obj5 = 0 ;
44672 PyObject * obj6 = 0 ;
44673 char * kwnames[] = {
44674 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
44675 };
44676
44677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
44678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
44679 if (!SWIG_IsOK(res1)) {
44680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
44681 }
44682 arg1 = reinterpret_cast< wxWindow * >(argp1);
44683 if (obj1) {
44684 ecode2 = SWIG_AsVal_int(obj1, &val2);
44685 if (!SWIG_IsOK(ecode2)) {
44686 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
44687 }
44688 arg2 = static_cast< int >(val2);
44689 }
44690 if (obj2) {
44691 {
44692 arg3 = &temp3;
44693 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
44694 }
44695 }
44696 if (obj3) {
44697 {
44698 arg4 = &temp4;
44699 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
44700 }
44701 }
44702 if (obj4) {
44703 ecode5 = SWIG_AsVal_long(obj4, &val5);
44704 if (!SWIG_IsOK(ecode5)) {
44705 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
44706 }
44707 arg5 = static_cast< long >(val5);
44708 }
44709 if (obj5) {
44710 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
44711 if (!SWIG_IsOK(res6)) {
44712 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
44713 }
44714 if (!argp6) {
44715 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
44716 }
44717 arg6 = reinterpret_cast< wxValidator * >(argp6);
44718 }
44719 if (obj6) {
44720 {
44721 arg7 = wxString_in_helper(obj6);
44722 if (arg7 == NULL) SWIG_fail;
44723 temp7 = true;
44724 }
44725 }
44726 {
44727 if (!wxPyCheckForApp()) SWIG_fail;
44728 PyThreadState* __tstate = wxPyBeginAllowThreads();
44729 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
44730 wxPyEndAllowThreads(__tstate);
44731 if (PyErr_Occurred()) SWIG_fail;
44732 }
44733 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
44734 {
44735 if (temp7)
44736 delete arg7;
44737 }
44738 return resultobj;
44739 fail:
44740 {
44741 if (temp7)
44742 delete arg7;
44743 }
44744 return NULL;
44745 }
44746
44747
44748 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44749 PyObject *resultobj = 0;
44750 wxControl *result = 0 ;
44751
44752 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
44753 {
44754 if (!wxPyCheckForApp()) SWIG_fail;
44755 PyThreadState* __tstate = wxPyBeginAllowThreads();
44756 result = (wxControl *)new wxControl();
44757 wxPyEndAllowThreads(__tstate);
44758 if (PyErr_Occurred()) SWIG_fail;
44759 }
44760 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
44761 return resultobj;
44762 fail:
44763 return NULL;
44764 }
44765
44766
44767 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44768 PyObject *resultobj = 0;
44769 wxControl *arg1 = (wxControl *) 0 ;
44770 wxWindow *arg2 = (wxWindow *) 0 ;
44771 int arg3 = (int) -1 ;
44772 wxPoint const &arg4_defvalue = wxDefaultPosition ;
44773 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
44774 wxSize const &arg5_defvalue = wxDefaultSize ;
44775 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
44776 long arg6 = (long) 0 ;
44777 wxValidator const &arg7_defvalue = wxDefaultValidator ;
44778 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
44779 wxString const &arg8_defvalue = wxPyControlNameStr ;
44780 wxString *arg8 = (wxString *) &arg8_defvalue ;
44781 bool result;
44782 void *argp1 = 0 ;
44783 int res1 = 0 ;
44784 void *argp2 = 0 ;
44785 int res2 = 0 ;
44786 int val3 ;
44787 int ecode3 = 0 ;
44788 wxPoint temp4 ;
44789 wxSize temp5 ;
44790 long val6 ;
44791 int ecode6 = 0 ;
44792 void *argp7 = 0 ;
44793 int res7 = 0 ;
44794 bool temp8 = false ;
44795 PyObject * obj0 = 0 ;
44796 PyObject * obj1 = 0 ;
44797 PyObject * obj2 = 0 ;
44798 PyObject * obj3 = 0 ;
44799 PyObject * obj4 = 0 ;
44800 PyObject * obj5 = 0 ;
44801 PyObject * obj6 = 0 ;
44802 PyObject * obj7 = 0 ;
44803 char * kwnames[] = {
44804 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
44805 };
44806
44807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
44808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44809 if (!SWIG_IsOK(res1)) {
44810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
44811 }
44812 arg1 = reinterpret_cast< wxControl * >(argp1);
44813 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
44814 if (!SWIG_IsOK(res2)) {
44815 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
44816 }
44817 arg2 = reinterpret_cast< wxWindow * >(argp2);
44818 if (obj2) {
44819 ecode3 = SWIG_AsVal_int(obj2, &val3);
44820 if (!SWIG_IsOK(ecode3)) {
44821 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
44822 }
44823 arg3 = static_cast< int >(val3);
44824 }
44825 if (obj3) {
44826 {
44827 arg4 = &temp4;
44828 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
44829 }
44830 }
44831 if (obj4) {
44832 {
44833 arg5 = &temp5;
44834 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
44835 }
44836 }
44837 if (obj5) {
44838 ecode6 = SWIG_AsVal_long(obj5, &val6);
44839 if (!SWIG_IsOK(ecode6)) {
44840 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
44841 }
44842 arg6 = static_cast< long >(val6);
44843 }
44844 if (obj6) {
44845 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
44846 if (!SWIG_IsOK(res7)) {
44847 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44848 }
44849 if (!argp7) {
44850 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44851 }
44852 arg7 = reinterpret_cast< wxValidator * >(argp7);
44853 }
44854 if (obj7) {
44855 {
44856 arg8 = wxString_in_helper(obj7);
44857 if (arg8 == NULL) SWIG_fail;
44858 temp8 = true;
44859 }
44860 }
44861 {
44862 PyThreadState* __tstate = wxPyBeginAllowThreads();
44863 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
44864 wxPyEndAllowThreads(__tstate);
44865 if (PyErr_Occurred()) SWIG_fail;
44866 }
44867 {
44868 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44869 }
44870 {
44871 if (temp8)
44872 delete arg8;
44873 }
44874 return resultobj;
44875 fail:
44876 {
44877 if (temp8)
44878 delete arg8;
44879 }
44880 return NULL;
44881 }
44882
44883
44884 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44885 PyObject *resultobj = 0;
44886 wxControl *arg1 = (wxControl *) 0 ;
44887 int result;
44888 void *argp1 = 0 ;
44889 int res1 = 0 ;
44890 PyObject *swig_obj[1] ;
44891
44892 if (!args) SWIG_fail;
44893 swig_obj[0] = args;
44894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44895 if (!SWIG_IsOK(res1)) {
44896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
44897 }
44898 arg1 = reinterpret_cast< wxControl * >(argp1);
44899 {
44900 PyThreadState* __tstate = wxPyBeginAllowThreads();
44901 result = (int)((wxControl const *)arg1)->GetAlignment();
44902 wxPyEndAllowThreads(__tstate);
44903 if (PyErr_Occurred()) SWIG_fail;
44904 }
44905 resultobj = SWIG_From_int(static_cast< int >(result));
44906 return resultobj;
44907 fail:
44908 return NULL;
44909 }
44910
44911
44912 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44913 PyObject *resultobj = 0;
44914 wxControl *arg1 = (wxControl *) 0 ;
44915 wxString result;
44916 void *argp1 = 0 ;
44917 int res1 = 0 ;
44918 PyObject *swig_obj[1] ;
44919
44920 if (!args) SWIG_fail;
44921 swig_obj[0] = args;
44922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44923 if (!SWIG_IsOK(res1)) {
44924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
44925 }
44926 arg1 = reinterpret_cast< wxControl * >(argp1);
44927 {
44928 PyThreadState* __tstate = wxPyBeginAllowThreads();
44929 result = ((wxControl const *)arg1)->GetLabelText();
44930 wxPyEndAllowThreads(__tstate);
44931 if (PyErr_Occurred()) SWIG_fail;
44932 }
44933 {
44934 #if wxUSE_UNICODE
44935 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44936 #else
44937 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44938 #endif
44939 }
44940 return resultobj;
44941 fail:
44942 return NULL;
44943 }
44944
44945
44946 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44947 PyObject *resultobj = 0;
44948 wxControl *arg1 = (wxControl *) 0 ;
44949 wxCommandEvent *arg2 = 0 ;
44950 void *argp1 = 0 ;
44951 int res1 = 0 ;
44952 void *argp2 = 0 ;
44953 int res2 = 0 ;
44954 PyObject * obj0 = 0 ;
44955 PyObject * obj1 = 0 ;
44956 char * kwnames[] = {
44957 (char *) "self",(char *) "event", NULL
44958 };
44959
44960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
44961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44962 if (!SWIG_IsOK(res1)) {
44963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
44964 }
44965 arg1 = reinterpret_cast< wxControl * >(argp1);
44966 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
44967 if (!SWIG_IsOK(res2)) {
44968 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44969 }
44970 if (!argp2) {
44971 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44972 }
44973 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
44974 {
44975 PyThreadState* __tstate = wxPyBeginAllowThreads();
44976 (arg1)->Command(*arg2);
44977 wxPyEndAllowThreads(__tstate);
44978 if (PyErr_Occurred()) SWIG_fail;
44979 }
44980 resultobj = SWIG_Py_Void();
44981 return resultobj;
44982 fail:
44983 return NULL;
44984 }
44985
44986
44987 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44988 PyObject *resultobj = 0;
44989 wxControl *arg1 = (wxControl *) 0 ;
44990 wxString result;
44991 void *argp1 = 0 ;
44992 int res1 = 0 ;
44993 PyObject *swig_obj[1] ;
44994
44995 if (!args) SWIG_fail;
44996 swig_obj[0] = args;
44997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44998 if (!SWIG_IsOK(res1)) {
44999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
45000 }
45001 arg1 = reinterpret_cast< wxControl * >(argp1);
45002 {
45003 PyThreadState* __tstate = wxPyBeginAllowThreads();
45004 result = (arg1)->GetLabel();
45005 wxPyEndAllowThreads(__tstate);
45006 if (PyErr_Occurred()) SWIG_fail;
45007 }
45008 {
45009 #if wxUSE_UNICODE
45010 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45011 #else
45012 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45013 #endif
45014 }
45015 return resultobj;
45016 fail:
45017 return NULL;
45018 }
45019
45020
45021 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45022 PyObject *resultobj = 0;
45023 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
45024 SwigValueWrapper<wxVisualAttributes > result;
45025 int val1 ;
45026 int ecode1 = 0 ;
45027 PyObject * obj0 = 0 ;
45028 char * kwnames[] = {
45029 (char *) "variant", NULL
45030 };
45031
45032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
45033 if (obj0) {
45034 ecode1 = SWIG_AsVal_int(obj0, &val1);
45035 if (!SWIG_IsOK(ecode1)) {
45036 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
45037 }
45038 arg1 = static_cast< wxWindowVariant >(val1);
45039 }
45040 {
45041 if (!wxPyCheckForApp()) SWIG_fail;
45042 PyThreadState* __tstate = wxPyBeginAllowThreads();
45043 result = wxControl::GetClassDefaultAttributes(arg1);
45044 wxPyEndAllowThreads(__tstate);
45045 if (PyErr_Occurred()) SWIG_fail;
45046 }
45047 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
45048 return resultobj;
45049 fail:
45050 return NULL;
45051 }
45052
45053
45054 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45055 PyObject *obj;
45056 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45057 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
45058 return SWIG_Py_Void();
45059 }
45060
45061 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45062 return SWIG_Python_InitShadowInstance(args);
45063 }
45064
45065 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45066 PyObject *resultobj = 0;
45067 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45068 wxString *arg2 = 0 ;
45069 PyObject *arg3 = (PyObject *) NULL ;
45070 int result;
45071 void *argp1 = 0 ;
45072 int res1 = 0 ;
45073 bool temp2 = false ;
45074 PyObject * obj0 = 0 ;
45075 PyObject * obj1 = 0 ;
45076 PyObject * obj2 = 0 ;
45077 char * kwnames[] = {
45078 (char *) "self",(char *) "item",(char *) "clientData", NULL
45079 };
45080
45081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45083 if (!SWIG_IsOK(res1)) {
45084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45085 }
45086 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45087 {
45088 arg2 = wxString_in_helper(obj1);
45089 if (arg2 == NULL) SWIG_fail;
45090 temp2 = true;
45091 }
45092 if (obj2) {
45093 arg3 = obj2;
45094 }
45095 {
45096 PyThreadState* __tstate = wxPyBeginAllowThreads();
45097 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
45098 wxPyEndAllowThreads(__tstate);
45099 if (PyErr_Occurred()) SWIG_fail;
45100 }
45101 resultobj = SWIG_From_int(static_cast< int >(result));
45102 {
45103 if (temp2)
45104 delete arg2;
45105 }
45106 return resultobj;
45107 fail:
45108 {
45109 if (temp2)
45110 delete arg2;
45111 }
45112 return NULL;
45113 }
45114
45115
45116 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45117 PyObject *resultobj = 0;
45118 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45119 wxArrayString *arg2 = 0 ;
45120 void *argp1 = 0 ;
45121 int res1 = 0 ;
45122 bool temp2 = false ;
45123 PyObject * obj0 = 0 ;
45124 PyObject * obj1 = 0 ;
45125 char * kwnames[] = {
45126 (char *) "self",(char *) "strings", NULL
45127 };
45128
45129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
45130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45131 if (!SWIG_IsOK(res1)) {
45132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45133 }
45134 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45135 {
45136 if (! PySequence_Check(obj1)) {
45137 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
45138 SWIG_fail;
45139 }
45140 arg2 = new wxArrayString;
45141 temp2 = true;
45142 int i, len=PySequence_Length(obj1);
45143 for (i=0; i<len; i++) {
45144 PyObject* item = PySequence_GetItem(obj1, i);
45145 wxString* s = wxString_in_helper(item);
45146 if (PyErr_Occurred()) SWIG_fail;
45147 arg2->Add(*s);
45148 delete s;
45149 Py_DECREF(item);
45150 }
45151 }
45152 {
45153 PyThreadState* __tstate = wxPyBeginAllowThreads();
45154 (arg1)->Append((wxArrayString const &)*arg2);
45155 wxPyEndAllowThreads(__tstate);
45156 if (PyErr_Occurred()) SWIG_fail;
45157 }
45158 resultobj = SWIG_Py_Void();
45159 {
45160 if (temp2) delete arg2;
45161 }
45162 return resultobj;
45163 fail:
45164 {
45165 if (temp2) delete arg2;
45166 }
45167 return NULL;
45168 }
45169
45170
45171 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45172 PyObject *resultobj = 0;
45173 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45174 wxString *arg2 = 0 ;
45175 unsigned int arg3 ;
45176 PyObject *arg4 = (PyObject *) NULL ;
45177 int result;
45178 void *argp1 = 0 ;
45179 int res1 = 0 ;
45180 bool temp2 = false ;
45181 unsigned int val3 ;
45182 int ecode3 = 0 ;
45183 PyObject * obj0 = 0 ;
45184 PyObject * obj1 = 0 ;
45185 PyObject * obj2 = 0 ;
45186 PyObject * obj3 = 0 ;
45187 char * kwnames[] = {
45188 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
45189 };
45190
45191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
45192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45193 if (!SWIG_IsOK(res1)) {
45194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45195 }
45196 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45197 {
45198 arg2 = wxString_in_helper(obj1);
45199 if (arg2 == NULL) SWIG_fail;
45200 temp2 = true;
45201 }
45202 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
45203 if (!SWIG_IsOK(ecode3)) {
45204 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
45205 }
45206 arg3 = static_cast< unsigned int >(val3);
45207 if (obj3) {
45208 arg4 = obj3;
45209 }
45210 {
45211 PyThreadState* __tstate = wxPyBeginAllowThreads();
45212 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
45213 wxPyEndAllowThreads(__tstate);
45214 if (PyErr_Occurred()) SWIG_fail;
45215 }
45216 resultobj = SWIG_From_int(static_cast< int >(result));
45217 {
45218 if (temp2)
45219 delete arg2;
45220 }
45221 return resultobj;
45222 fail:
45223 {
45224 if (temp2)
45225 delete arg2;
45226 }
45227 return NULL;
45228 }
45229
45230
45231 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45232 PyObject *resultobj = 0;
45233 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45234 void *argp1 = 0 ;
45235 int res1 = 0 ;
45236 PyObject *swig_obj[1] ;
45237
45238 if (!args) SWIG_fail;
45239 swig_obj[0] = args;
45240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45241 if (!SWIG_IsOK(res1)) {
45242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45243 }
45244 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45245 {
45246 PyThreadState* __tstate = wxPyBeginAllowThreads();
45247 (arg1)->Clear();
45248 wxPyEndAllowThreads(__tstate);
45249 if (PyErr_Occurred()) SWIG_fail;
45250 }
45251 resultobj = SWIG_Py_Void();
45252 return resultobj;
45253 fail:
45254 return NULL;
45255 }
45256
45257
45258 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45259 PyObject *resultobj = 0;
45260 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45261 unsigned int arg2 ;
45262 void *argp1 = 0 ;
45263 int res1 = 0 ;
45264 unsigned int val2 ;
45265 int ecode2 = 0 ;
45266 PyObject * obj0 = 0 ;
45267 PyObject * obj1 = 0 ;
45268 char * kwnames[] = {
45269 (char *) "self",(char *) "n", NULL
45270 };
45271
45272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
45273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45274 if (!SWIG_IsOK(res1)) {
45275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45276 }
45277 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45278 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45279 if (!SWIG_IsOK(ecode2)) {
45280 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
45281 }
45282 arg2 = static_cast< unsigned int >(val2);
45283 {
45284 PyThreadState* __tstate = wxPyBeginAllowThreads();
45285 (arg1)->Delete(arg2);
45286 wxPyEndAllowThreads(__tstate);
45287 if (PyErr_Occurred()) SWIG_fail;
45288 }
45289 resultobj = SWIG_Py_Void();
45290 return resultobj;
45291 fail:
45292 return NULL;
45293 }
45294
45295
45296 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45297 PyObject *resultobj = 0;
45298 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45299 unsigned int arg2 ;
45300 PyObject *result = 0 ;
45301 void *argp1 = 0 ;
45302 int res1 = 0 ;
45303 unsigned int val2 ;
45304 int ecode2 = 0 ;
45305 PyObject * obj0 = 0 ;
45306 PyObject * obj1 = 0 ;
45307 char * kwnames[] = {
45308 (char *) "self",(char *) "n", NULL
45309 };
45310
45311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
45312 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45313 if (!SWIG_IsOK(res1)) {
45314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45315 }
45316 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45317 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45318 if (!SWIG_IsOK(ecode2)) {
45319 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
45320 }
45321 arg2 = static_cast< unsigned int >(val2);
45322 {
45323 PyThreadState* __tstate = wxPyBeginAllowThreads();
45324 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
45325 wxPyEndAllowThreads(__tstate);
45326 if (PyErr_Occurred()) SWIG_fail;
45327 }
45328 resultobj = result;
45329 return resultobj;
45330 fail:
45331 return NULL;
45332 }
45333
45334
45335 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45336 PyObject *resultobj = 0;
45337 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45338 unsigned int arg2 ;
45339 PyObject *arg3 = (PyObject *) 0 ;
45340 void *argp1 = 0 ;
45341 int res1 = 0 ;
45342 unsigned int val2 ;
45343 int ecode2 = 0 ;
45344 PyObject * obj0 = 0 ;
45345 PyObject * obj1 = 0 ;
45346 PyObject * obj2 = 0 ;
45347 char * kwnames[] = {
45348 (char *) "self",(char *) "n",(char *) "clientData", NULL
45349 };
45350
45351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45353 if (!SWIG_IsOK(res1)) {
45354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45355 }
45356 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45357 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45358 if (!SWIG_IsOK(ecode2)) {
45359 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
45360 }
45361 arg2 = static_cast< unsigned int >(val2);
45362 arg3 = obj2;
45363 {
45364 PyThreadState* __tstate = wxPyBeginAllowThreads();
45365 wxItemContainer_SetClientData(arg1,arg2,arg3);
45366 wxPyEndAllowThreads(__tstate);
45367 if (PyErr_Occurred()) SWIG_fail;
45368 }
45369 resultobj = SWIG_Py_Void();
45370 return resultobj;
45371 fail:
45372 return NULL;
45373 }
45374
45375
45376 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45377 PyObject *resultobj = 0;
45378 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45379 unsigned int result;
45380 void *argp1 = 0 ;
45381 int res1 = 0 ;
45382 PyObject *swig_obj[1] ;
45383
45384 if (!args) SWIG_fail;
45385 swig_obj[0] = args;
45386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45387 if (!SWIG_IsOK(res1)) {
45388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45389 }
45390 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45391 {
45392 PyThreadState* __tstate = wxPyBeginAllowThreads();
45393 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
45394 wxPyEndAllowThreads(__tstate);
45395 if (PyErr_Occurred()) SWIG_fail;
45396 }
45397 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
45398 return resultobj;
45399 fail:
45400 return NULL;
45401 }
45402
45403
45404 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45405 PyObject *resultobj = 0;
45406 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45407 bool result;
45408 void *argp1 = 0 ;
45409 int res1 = 0 ;
45410 PyObject *swig_obj[1] ;
45411
45412 if (!args) SWIG_fail;
45413 swig_obj[0] = args;
45414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45415 if (!SWIG_IsOK(res1)) {
45416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45417 }
45418 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45419 {
45420 PyThreadState* __tstate = wxPyBeginAllowThreads();
45421 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
45422 wxPyEndAllowThreads(__tstate);
45423 if (PyErr_Occurred()) SWIG_fail;
45424 }
45425 {
45426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45427 }
45428 return resultobj;
45429 fail:
45430 return NULL;
45431 }
45432
45433
45434 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45435 PyObject *resultobj = 0;
45436 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45437 unsigned int arg2 ;
45438 wxString result;
45439 void *argp1 = 0 ;
45440 int res1 = 0 ;
45441 unsigned int val2 ;
45442 int ecode2 = 0 ;
45443 PyObject * obj0 = 0 ;
45444 PyObject * obj1 = 0 ;
45445 char * kwnames[] = {
45446 (char *) "self",(char *) "n", NULL
45447 };
45448
45449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
45450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45451 if (!SWIG_IsOK(res1)) {
45452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45453 }
45454 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45455 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45456 if (!SWIG_IsOK(ecode2)) {
45457 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
45458 }
45459 arg2 = static_cast< unsigned int >(val2);
45460 {
45461 PyThreadState* __tstate = wxPyBeginAllowThreads();
45462 result = ((wxItemContainer const *)arg1)->GetString(arg2);
45463 wxPyEndAllowThreads(__tstate);
45464 if (PyErr_Occurred()) SWIG_fail;
45465 }
45466 {
45467 #if wxUSE_UNICODE
45468 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45469 #else
45470 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45471 #endif
45472 }
45473 return resultobj;
45474 fail:
45475 return NULL;
45476 }
45477
45478
45479 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45480 PyObject *resultobj = 0;
45481 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45482 wxArrayString result;
45483 void *argp1 = 0 ;
45484 int res1 = 0 ;
45485 PyObject *swig_obj[1] ;
45486
45487 if (!args) SWIG_fail;
45488 swig_obj[0] = args;
45489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45490 if (!SWIG_IsOK(res1)) {
45491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45492 }
45493 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45494 {
45495 PyThreadState* __tstate = wxPyBeginAllowThreads();
45496 result = ((wxItemContainer const *)arg1)->GetStrings();
45497 wxPyEndAllowThreads(__tstate);
45498 if (PyErr_Occurred()) SWIG_fail;
45499 }
45500 {
45501 resultobj = wxArrayString2PyList_helper(result);
45502 }
45503 return resultobj;
45504 fail:
45505 return NULL;
45506 }
45507
45508
45509 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45510 PyObject *resultobj = 0;
45511 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45512 unsigned int arg2 ;
45513 wxString *arg3 = 0 ;
45514 void *argp1 = 0 ;
45515 int res1 = 0 ;
45516 unsigned int val2 ;
45517 int ecode2 = 0 ;
45518 bool temp3 = false ;
45519 PyObject * obj0 = 0 ;
45520 PyObject * obj1 = 0 ;
45521 PyObject * obj2 = 0 ;
45522 char * kwnames[] = {
45523 (char *) "self",(char *) "n",(char *) "s", NULL
45524 };
45525
45526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45528 if (!SWIG_IsOK(res1)) {
45529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45530 }
45531 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45532 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45533 if (!SWIG_IsOK(ecode2)) {
45534 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
45535 }
45536 arg2 = static_cast< unsigned int >(val2);
45537 {
45538 arg3 = wxString_in_helper(obj2);
45539 if (arg3 == NULL) SWIG_fail;
45540 temp3 = true;
45541 }
45542 {
45543 PyThreadState* __tstate = wxPyBeginAllowThreads();
45544 (arg1)->SetString(arg2,(wxString const &)*arg3);
45545 wxPyEndAllowThreads(__tstate);
45546 if (PyErr_Occurred()) SWIG_fail;
45547 }
45548 resultobj = SWIG_Py_Void();
45549 {
45550 if (temp3)
45551 delete arg3;
45552 }
45553 return resultobj;
45554 fail:
45555 {
45556 if (temp3)
45557 delete arg3;
45558 }
45559 return NULL;
45560 }
45561
45562
45563 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45564 PyObject *resultobj = 0;
45565 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45566 wxString *arg2 = 0 ;
45567 int result;
45568 void *argp1 = 0 ;
45569 int res1 = 0 ;
45570 bool temp2 = false ;
45571 PyObject * obj0 = 0 ;
45572 PyObject * obj1 = 0 ;
45573 char * kwnames[] = {
45574 (char *) "self",(char *) "s", NULL
45575 };
45576
45577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
45578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45579 if (!SWIG_IsOK(res1)) {
45580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45581 }
45582 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45583 {
45584 arg2 = wxString_in_helper(obj1);
45585 if (arg2 == NULL) SWIG_fail;
45586 temp2 = true;
45587 }
45588 {
45589 PyThreadState* __tstate = wxPyBeginAllowThreads();
45590 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
45591 wxPyEndAllowThreads(__tstate);
45592 if (PyErr_Occurred()) SWIG_fail;
45593 }
45594 resultobj = SWIG_From_int(static_cast< int >(result));
45595 {
45596 if (temp2)
45597 delete arg2;
45598 }
45599 return resultobj;
45600 fail:
45601 {
45602 if (temp2)
45603 delete arg2;
45604 }
45605 return NULL;
45606 }
45607
45608
45609 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45610 PyObject *resultobj = 0;
45611 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45612 int arg2 ;
45613 void *argp1 = 0 ;
45614 int res1 = 0 ;
45615 int val2 ;
45616 int ecode2 = 0 ;
45617 PyObject * obj0 = 0 ;
45618 PyObject * obj1 = 0 ;
45619 char * kwnames[] = {
45620 (char *) "self",(char *) "n", NULL
45621 };
45622
45623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
45624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45625 if (!SWIG_IsOK(res1)) {
45626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45627 }
45628 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45629 ecode2 = SWIG_AsVal_int(obj1, &val2);
45630 if (!SWIG_IsOK(ecode2)) {
45631 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
45632 }
45633 arg2 = static_cast< int >(val2);
45634 {
45635 PyThreadState* __tstate = wxPyBeginAllowThreads();
45636 (arg1)->SetSelection(arg2);
45637 wxPyEndAllowThreads(__tstate);
45638 if (PyErr_Occurred()) SWIG_fail;
45639 }
45640 resultobj = SWIG_Py_Void();
45641 return resultobj;
45642 fail:
45643 return NULL;
45644 }
45645
45646
45647 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45648 PyObject *resultobj = 0;
45649 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45650 int result;
45651 void *argp1 = 0 ;
45652 int res1 = 0 ;
45653 PyObject *swig_obj[1] ;
45654
45655 if (!args) SWIG_fail;
45656 swig_obj[0] = args;
45657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45658 if (!SWIG_IsOK(res1)) {
45659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45660 }
45661 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45662 {
45663 PyThreadState* __tstate = wxPyBeginAllowThreads();
45664 result = (int)((wxItemContainer const *)arg1)->GetSelection();
45665 wxPyEndAllowThreads(__tstate);
45666 if (PyErr_Occurred()) SWIG_fail;
45667 }
45668 resultobj = SWIG_From_int(static_cast< int >(result));
45669 return resultobj;
45670 fail:
45671 return NULL;
45672 }
45673
45674
45675 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45676 PyObject *resultobj = 0;
45677 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45678 wxString *arg2 = 0 ;
45679 bool result;
45680 void *argp1 = 0 ;
45681 int res1 = 0 ;
45682 bool temp2 = false ;
45683 PyObject * obj0 = 0 ;
45684 PyObject * obj1 = 0 ;
45685 char * kwnames[] = {
45686 (char *) "self",(char *) "s", NULL
45687 };
45688
45689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
45690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45691 if (!SWIG_IsOK(res1)) {
45692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45693 }
45694 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45695 {
45696 arg2 = wxString_in_helper(obj1);
45697 if (arg2 == NULL) SWIG_fail;
45698 temp2 = true;
45699 }
45700 {
45701 PyThreadState* __tstate = wxPyBeginAllowThreads();
45702 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
45703 wxPyEndAllowThreads(__tstate);
45704 if (PyErr_Occurred()) SWIG_fail;
45705 }
45706 {
45707 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45708 }
45709 {
45710 if (temp2)
45711 delete arg2;
45712 }
45713 return resultobj;
45714 fail:
45715 {
45716 if (temp2)
45717 delete arg2;
45718 }
45719 return NULL;
45720 }
45721
45722
45723 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45724 PyObject *resultobj = 0;
45725 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45726 wxString result;
45727 void *argp1 = 0 ;
45728 int res1 = 0 ;
45729 PyObject *swig_obj[1] ;
45730
45731 if (!args) SWIG_fail;
45732 swig_obj[0] = args;
45733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45734 if (!SWIG_IsOK(res1)) {
45735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45736 }
45737 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45738 {
45739 PyThreadState* __tstate = wxPyBeginAllowThreads();
45740 result = ((wxItemContainer const *)arg1)->GetStringSelection();
45741 wxPyEndAllowThreads(__tstate);
45742 if (PyErr_Occurred()) SWIG_fail;
45743 }
45744 {
45745 #if wxUSE_UNICODE
45746 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45747 #else
45748 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45749 #endif
45750 }
45751 return resultobj;
45752 fail:
45753 return NULL;
45754 }
45755
45756
45757 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45758 PyObject *resultobj = 0;
45759 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45760 int arg2 ;
45761 void *argp1 = 0 ;
45762 int res1 = 0 ;
45763 int val2 ;
45764 int ecode2 = 0 ;
45765 PyObject * obj0 = 0 ;
45766 PyObject * obj1 = 0 ;
45767 char * kwnames[] = {
45768 (char *) "self",(char *) "n", NULL
45769 };
45770
45771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
45772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45773 if (!SWIG_IsOK(res1)) {
45774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45775 }
45776 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45777 ecode2 = SWIG_AsVal_int(obj1, &val2);
45778 if (!SWIG_IsOK(ecode2)) {
45779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
45780 }
45781 arg2 = static_cast< int >(val2);
45782 {
45783 PyThreadState* __tstate = wxPyBeginAllowThreads();
45784 (arg1)->Select(arg2);
45785 wxPyEndAllowThreads(__tstate);
45786 if (PyErr_Occurred()) SWIG_fail;
45787 }
45788 resultobj = SWIG_Py_Void();
45789 return resultobj;
45790 fail:
45791 return NULL;
45792 }
45793
45794
45795 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45796 PyObject *obj;
45797 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45798 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
45799 return SWIG_Py_Void();
45800 }
45801
45802 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45803 PyObject *obj;
45804 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45805 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
45806 return SWIG_Py_Void();
45807 }
45808
45809 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45810 PyObject *resultobj = 0;
45811 wxSizerItem *result = 0 ;
45812
45813 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
45814 {
45815 PyThreadState* __tstate = wxPyBeginAllowThreads();
45816 result = (wxSizerItem *)new wxSizerItem();
45817 wxPyEndAllowThreads(__tstate);
45818 if (PyErr_Occurred()) SWIG_fail;
45819 }
45820 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
45821 return resultobj;
45822 fail:
45823 return NULL;
45824 }
45825
45826
45827 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45828 PyObject *resultobj = 0;
45829 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45830 void *argp1 = 0 ;
45831 int res1 = 0 ;
45832 PyObject *swig_obj[1] ;
45833
45834 if (!args) SWIG_fail;
45835 swig_obj[0] = args;
45836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
45837 if (!SWIG_IsOK(res1)) {
45838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45839 }
45840 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45841 {
45842 PyThreadState* __tstate = wxPyBeginAllowThreads();
45843 delete arg1;
45844
45845 wxPyEndAllowThreads(__tstate);
45846 if (PyErr_Occurred()) SWIG_fail;
45847 }
45848 resultobj = SWIG_Py_Void();
45849 return resultobj;
45850 fail:
45851 return NULL;
45852 }
45853
45854
45855 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45856 PyObject *resultobj = 0;
45857 wxWindow *arg1 = (wxWindow *) 0 ;
45858 int arg2 ;
45859 int arg3 ;
45860 int arg4 ;
45861 PyObject *arg5 = (PyObject *) NULL ;
45862 wxSizerItem *result = 0 ;
45863 void *argp1 = 0 ;
45864 int res1 = 0 ;
45865 int val2 ;
45866 int ecode2 = 0 ;
45867 int val3 ;
45868 int ecode3 = 0 ;
45869 int val4 ;
45870 int ecode4 = 0 ;
45871 PyObject * obj0 = 0 ;
45872 PyObject * obj1 = 0 ;
45873 PyObject * obj2 = 0 ;
45874 PyObject * obj3 = 0 ;
45875 PyObject * obj4 = 0 ;
45876 char * kwnames[] = {
45877 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45878 };
45879
45880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
45882 if (!SWIG_IsOK(res1)) {
45883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
45884 }
45885 arg1 = reinterpret_cast< wxWindow * >(argp1);
45886 ecode2 = SWIG_AsVal_int(obj1, &val2);
45887 if (!SWIG_IsOK(ecode2)) {
45888 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
45889 }
45890 arg2 = static_cast< int >(val2);
45891 ecode3 = SWIG_AsVal_int(obj2, &val3);
45892 if (!SWIG_IsOK(ecode3)) {
45893 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
45894 }
45895 arg3 = static_cast< int >(val3);
45896 ecode4 = SWIG_AsVal_int(obj3, &val4);
45897 if (!SWIG_IsOK(ecode4)) {
45898 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
45899 }
45900 arg4 = static_cast< int >(val4);
45901 if (obj4) {
45902 arg5 = obj4;
45903 }
45904 {
45905 PyThreadState* __tstate = wxPyBeginAllowThreads();
45906 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45907 wxPyEndAllowThreads(__tstate);
45908 if (PyErr_Occurred()) SWIG_fail;
45909 }
45910 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45911 return resultobj;
45912 fail:
45913 return NULL;
45914 }
45915
45916
45917 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45918 PyObject *resultobj = 0;
45919 int arg1 ;
45920 int arg2 ;
45921 int arg3 ;
45922 int arg4 ;
45923 int arg5 ;
45924 PyObject *arg6 = (PyObject *) NULL ;
45925 wxSizerItem *result = 0 ;
45926 int val1 ;
45927 int ecode1 = 0 ;
45928 int val2 ;
45929 int ecode2 = 0 ;
45930 int val3 ;
45931 int ecode3 = 0 ;
45932 int val4 ;
45933 int ecode4 = 0 ;
45934 int val5 ;
45935 int ecode5 = 0 ;
45936 PyObject * obj0 = 0 ;
45937 PyObject * obj1 = 0 ;
45938 PyObject * obj2 = 0 ;
45939 PyObject * obj3 = 0 ;
45940 PyObject * obj4 = 0 ;
45941 PyObject * obj5 = 0 ;
45942 char * kwnames[] = {
45943 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45944 };
45945
45946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45947 ecode1 = SWIG_AsVal_int(obj0, &val1);
45948 if (!SWIG_IsOK(ecode1)) {
45949 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
45950 }
45951 arg1 = static_cast< int >(val1);
45952 ecode2 = SWIG_AsVal_int(obj1, &val2);
45953 if (!SWIG_IsOK(ecode2)) {
45954 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
45955 }
45956 arg2 = static_cast< int >(val2);
45957 ecode3 = SWIG_AsVal_int(obj2, &val3);
45958 if (!SWIG_IsOK(ecode3)) {
45959 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
45960 }
45961 arg3 = static_cast< int >(val3);
45962 ecode4 = SWIG_AsVal_int(obj3, &val4);
45963 if (!SWIG_IsOK(ecode4)) {
45964 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
45965 }
45966 arg4 = static_cast< int >(val4);
45967 ecode5 = SWIG_AsVal_int(obj4, &val5);
45968 if (!SWIG_IsOK(ecode5)) {
45969 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
45970 }
45971 arg5 = static_cast< int >(val5);
45972 if (obj5) {
45973 arg6 = obj5;
45974 }
45975 {
45976 PyThreadState* __tstate = wxPyBeginAllowThreads();
45977 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
45978 wxPyEndAllowThreads(__tstate);
45979 if (PyErr_Occurred()) SWIG_fail;
45980 }
45981 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45982 return resultobj;
45983 fail:
45984 return NULL;
45985 }
45986
45987
45988 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45989 PyObject *resultobj = 0;
45990 wxSizer *arg1 = (wxSizer *) 0 ;
45991 int arg2 ;
45992 int arg3 ;
45993 int arg4 ;
45994 PyObject *arg5 = (PyObject *) NULL ;
45995 wxSizerItem *result = 0 ;
45996 int res1 = 0 ;
45997 int val2 ;
45998 int ecode2 = 0 ;
45999 int val3 ;
46000 int ecode3 = 0 ;
46001 int val4 ;
46002 int ecode4 = 0 ;
46003 PyObject * obj0 = 0 ;
46004 PyObject * obj1 = 0 ;
46005 PyObject * obj2 = 0 ;
46006 PyObject * obj3 = 0 ;
46007 PyObject * obj4 = 0 ;
46008 char * kwnames[] = {
46009 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46010 };
46011
46012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46013 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46014 if (!SWIG_IsOK(res1)) {
46015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
46016 }
46017 ecode2 = SWIG_AsVal_int(obj1, &val2);
46018 if (!SWIG_IsOK(ecode2)) {
46019 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
46020 }
46021 arg2 = static_cast< int >(val2);
46022 ecode3 = SWIG_AsVal_int(obj2, &val3);
46023 if (!SWIG_IsOK(ecode3)) {
46024 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
46025 }
46026 arg3 = static_cast< int >(val3);
46027 ecode4 = SWIG_AsVal_int(obj3, &val4);
46028 if (!SWIG_IsOK(ecode4)) {
46029 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
46030 }
46031 arg4 = static_cast< int >(val4);
46032 if (obj4) {
46033 arg5 = obj4;
46034 }
46035 {
46036 PyThreadState* __tstate = wxPyBeginAllowThreads();
46037 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
46038 wxPyEndAllowThreads(__tstate);
46039 if (PyErr_Occurred()) SWIG_fail;
46040 }
46041 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
46042 return resultobj;
46043 fail:
46044 return NULL;
46045 }
46046
46047
46048 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46049 PyObject *resultobj = 0;
46050 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46051 void *argp1 = 0 ;
46052 int res1 = 0 ;
46053 PyObject *swig_obj[1] ;
46054
46055 if (!args) SWIG_fail;
46056 swig_obj[0] = args;
46057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46058 if (!SWIG_IsOK(res1)) {
46059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46060 }
46061 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46062 {
46063 PyThreadState* __tstate = wxPyBeginAllowThreads();
46064 (arg1)->DeleteWindows();
46065 wxPyEndAllowThreads(__tstate);
46066 if (PyErr_Occurred()) SWIG_fail;
46067 }
46068 resultobj = SWIG_Py_Void();
46069 return resultobj;
46070 fail:
46071 return NULL;
46072 }
46073
46074
46075 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46076 PyObject *resultobj = 0;
46077 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46078 void *argp1 = 0 ;
46079 int res1 = 0 ;
46080 PyObject *swig_obj[1] ;
46081
46082 if (!args) SWIG_fail;
46083 swig_obj[0] = args;
46084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46085 if (!SWIG_IsOK(res1)) {
46086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46087 }
46088 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46089 {
46090 PyThreadState* __tstate = wxPyBeginAllowThreads();
46091 (arg1)->DetachSizer();
46092 wxPyEndAllowThreads(__tstate);
46093 if (PyErr_Occurred()) SWIG_fail;
46094 }
46095 resultobj = SWIG_Py_Void();
46096 return resultobj;
46097 fail:
46098 return NULL;
46099 }
46100
46101
46102 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46103 PyObject *resultobj = 0;
46104 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46105 wxSize result;
46106 void *argp1 = 0 ;
46107 int res1 = 0 ;
46108 PyObject *swig_obj[1] ;
46109
46110 if (!args) SWIG_fail;
46111 swig_obj[0] = args;
46112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46113 if (!SWIG_IsOK(res1)) {
46114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46115 }
46116 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46117 {
46118 PyThreadState* __tstate = wxPyBeginAllowThreads();
46119 result = (arg1)->GetSize();
46120 wxPyEndAllowThreads(__tstate);
46121 if (PyErr_Occurred()) SWIG_fail;
46122 }
46123 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46124 return resultobj;
46125 fail:
46126 return NULL;
46127 }
46128
46129
46130 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46131 PyObject *resultobj = 0;
46132 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46133 wxSize result;
46134 void *argp1 = 0 ;
46135 int res1 = 0 ;
46136 PyObject *swig_obj[1] ;
46137
46138 if (!args) SWIG_fail;
46139 swig_obj[0] = args;
46140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46141 if (!SWIG_IsOK(res1)) {
46142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46143 }
46144 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46145 {
46146 PyThreadState* __tstate = wxPyBeginAllowThreads();
46147 result = (arg1)->CalcMin();
46148 wxPyEndAllowThreads(__tstate);
46149 if (PyErr_Occurred()) SWIG_fail;
46150 }
46151 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46152 return resultobj;
46153 fail:
46154 return NULL;
46155 }
46156
46157
46158 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46159 PyObject *resultobj = 0;
46160 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46161 wxPoint *arg2 = 0 ;
46162 wxSize *arg3 = 0 ;
46163 void *argp1 = 0 ;
46164 int res1 = 0 ;
46165 wxPoint temp2 ;
46166 wxSize temp3 ;
46167 PyObject * obj0 = 0 ;
46168 PyObject * obj1 = 0 ;
46169 PyObject * obj2 = 0 ;
46170 char * kwnames[] = {
46171 (char *) "self",(char *) "pos",(char *) "size", NULL
46172 };
46173
46174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46176 if (!SWIG_IsOK(res1)) {
46177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46178 }
46179 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46180 {
46181 arg2 = &temp2;
46182 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
46183 }
46184 {
46185 arg3 = &temp3;
46186 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46187 }
46188 {
46189 PyThreadState* __tstate = wxPyBeginAllowThreads();
46190 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
46191 wxPyEndAllowThreads(__tstate);
46192 if (PyErr_Occurred()) SWIG_fail;
46193 }
46194 resultobj = SWIG_Py_Void();
46195 return resultobj;
46196 fail:
46197 return NULL;
46198 }
46199
46200
46201 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46202 PyObject *resultobj = 0;
46203 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46204 wxSize result;
46205 void *argp1 = 0 ;
46206 int res1 = 0 ;
46207 PyObject *swig_obj[1] ;
46208
46209 if (!args) SWIG_fail;
46210 swig_obj[0] = args;
46211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46212 if (!SWIG_IsOK(res1)) {
46213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46214 }
46215 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46216 {
46217 PyThreadState* __tstate = wxPyBeginAllowThreads();
46218 result = (arg1)->GetMinSize();
46219 wxPyEndAllowThreads(__tstate);
46220 if (PyErr_Occurred()) SWIG_fail;
46221 }
46222 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46223 return resultobj;
46224 fail:
46225 return NULL;
46226 }
46227
46228
46229 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46230 PyObject *resultobj = 0;
46231 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46232 wxSize result;
46233 void *argp1 = 0 ;
46234 int res1 = 0 ;
46235 PyObject *swig_obj[1] ;
46236
46237 if (!args) SWIG_fail;
46238 swig_obj[0] = args;
46239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46240 if (!SWIG_IsOK(res1)) {
46241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
46242 }
46243 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46244 {
46245 PyThreadState* __tstate = wxPyBeginAllowThreads();
46246 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
46247 wxPyEndAllowThreads(__tstate);
46248 if (PyErr_Occurred()) SWIG_fail;
46249 }
46250 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46251 return resultobj;
46252 fail:
46253 return NULL;
46254 }
46255
46256
46257 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46258 PyObject *resultobj = 0;
46259 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46260 int arg2 ;
46261 int arg3 ;
46262 void *argp1 = 0 ;
46263 int res1 = 0 ;
46264 int val2 ;
46265 int ecode2 = 0 ;
46266 int val3 ;
46267 int ecode3 = 0 ;
46268 PyObject * obj0 = 0 ;
46269 PyObject * obj1 = 0 ;
46270 PyObject * obj2 = 0 ;
46271 char * kwnames[] = {
46272 (char *) "self",(char *) "x",(char *) "y", NULL
46273 };
46274
46275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46277 if (!SWIG_IsOK(res1)) {
46278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46279 }
46280 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46281 ecode2 = SWIG_AsVal_int(obj1, &val2);
46282 if (!SWIG_IsOK(ecode2)) {
46283 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
46284 }
46285 arg2 = static_cast< int >(val2);
46286 ecode3 = SWIG_AsVal_int(obj2, &val3);
46287 if (!SWIG_IsOK(ecode3)) {
46288 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
46289 }
46290 arg3 = static_cast< int >(val3);
46291 {
46292 PyThreadState* __tstate = wxPyBeginAllowThreads();
46293 (arg1)->SetInitSize(arg2,arg3);
46294 wxPyEndAllowThreads(__tstate);
46295 if (PyErr_Occurred()) SWIG_fail;
46296 }
46297 resultobj = SWIG_Py_Void();
46298 return resultobj;
46299 fail:
46300 return NULL;
46301 }
46302
46303
46304 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46305 PyObject *resultobj = 0;
46306 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46307 int arg2 ;
46308 int arg3 ;
46309 void *argp1 = 0 ;
46310 int res1 = 0 ;
46311 int val2 ;
46312 int ecode2 = 0 ;
46313 int val3 ;
46314 int ecode3 = 0 ;
46315 PyObject * obj0 = 0 ;
46316 PyObject * obj1 = 0 ;
46317 PyObject * obj2 = 0 ;
46318 char * kwnames[] = {
46319 (char *) "self",(char *) "width",(char *) "height", NULL
46320 };
46321
46322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46324 if (!SWIG_IsOK(res1)) {
46325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46326 }
46327 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46328 ecode2 = SWIG_AsVal_int(obj1, &val2);
46329 if (!SWIG_IsOK(ecode2)) {
46330 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
46331 }
46332 arg2 = static_cast< int >(val2);
46333 ecode3 = SWIG_AsVal_int(obj2, &val3);
46334 if (!SWIG_IsOK(ecode3)) {
46335 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
46336 }
46337 arg3 = static_cast< int >(val3);
46338 {
46339 PyThreadState* __tstate = wxPyBeginAllowThreads();
46340 (arg1)->SetRatio(arg2,arg3);
46341 wxPyEndAllowThreads(__tstate);
46342 if (PyErr_Occurred()) SWIG_fail;
46343 }
46344 resultobj = SWIG_Py_Void();
46345 return resultobj;
46346 fail:
46347 return NULL;
46348 }
46349
46350
46351 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46352 PyObject *resultobj = 0;
46353 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46354 wxSize *arg2 = 0 ;
46355 void *argp1 = 0 ;
46356 int res1 = 0 ;
46357 wxSize temp2 ;
46358 PyObject * obj0 = 0 ;
46359 PyObject * obj1 = 0 ;
46360 char * kwnames[] = {
46361 (char *) "self",(char *) "size", NULL
46362 };
46363
46364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
46365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46366 if (!SWIG_IsOK(res1)) {
46367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46368 }
46369 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46370 {
46371 arg2 = &temp2;
46372 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46373 }
46374 {
46375 PyThreadState* __tstate = wxPyBeginAllowThreads();
46376 (arg1)->SetRatio((wxSize const &)*arg2);
46377 wxPyEndAllowThreads(__tstate);
46378 if (PyErr_Occurred()) SWIG_fail;
46379 }
46380 resultobj = SWIG_Py_Void();
46381 return resultobj;
46382 fail:
46383 return NULL;
46384 }
46385
46386
46387 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46388 PyObject *resultobj = 0;
46389 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46390 float arg2 ;
46391 void *argp1 = 0 ;
46392 int res1 = 0 ;
46393 float val2 ;
46394 int ecode2 = 0 ;
46395 PyObject * obj0 = 0 ;
46396 PyObject * obj1 = 0 ;
46397 char * kwnames[] = {
46398 (char *) "self",(char *) "ratio", NULL
46399 };
46400
46401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
46402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46403 if (!SWIG_IsOK(res1)) {
46404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46405 }
46406 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46407 ecode2 = SWIG_AsVal_float(obj1, &val2);
46408 if (!SWIG_IsOK(ecode2)) {
46409 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
46410 }
46411 arg2 = static_cast< float >(val2);
46412 {
46413 PyThreadState* __tstate = wxPyBeginAllowThreads();
46414 (arg1)->SetRatio(arg2);
46415 wxPyEndAllowThreads(__tstate);
46416 if (PyErr_Occurred()) SWIG_fail;
46417 }
46418 resultobj = SWIG_Py_Void();
46419 return resultobj;
46420 fail:
46421 return NULL;
46422 }
46423
46424
46425 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46426 PyObject *resultobj = 0;
46427 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46428 float result;
46429 void *argp1 = 0 ;
46430 int res1 = 0 ;
46431 PyObject *swig_obj[1] ;
46432
46433 if (!args) SWIG_fail;
46434 swig_obj[0] = args;
46435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46436 if (!SWIG_IsOK(res1)) {
46437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46438 }
46439 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46440 {
46441 PyThreadState* __tstate = wxPyBeginAllowThreads();
46442 result = (float)(arg1)->GetRatio();
46443 wxPyEndAllowThreads(__tstate);
46444 if (PyErr_Occurred()) SWIG_fail;
46445 }
46446 resultobj = SWIG_From_float(static_cast< float >(result));
46447 return resultobj;
46448 fail:
46449 return NULL;
46450 }
46451
46452
46453 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46454 PyObject *resultobj = 0;
46455 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46456 wxRect result;
46457 void *argp1 = 0 ;
46458 int res1 = 0 ;
46459 PyObject *swig_obj[1] ;
46460
46461 if (!args) SWIG_fail;
46462 swig_obj[0] = args;
46463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46464 if (!SWIG_IsOK(res1)) {
46465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46466 }
46467 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46468 {
46469 PyThreadState* __tstate = wxPyBeginAllowThreads();
46470 result = (arg1)->GetRect();
46471 wxPyEndAllowThreads(__tstate);
46472 if (PyErr_Occurred()) SWIG_fail;
46473 }
46474 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
46475 return resultobj;
46476 fail:
46477 return NULL;
46478 }
46479
46480
46481 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46482 PyObject *resultobj = 0;
46483 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46484 bool result;
46485 void *argp1 = 0 ;
46486 int res1 = 0 ;
46487 PyObject *swig_obj[1] ;
46488
46489 if (!args) SWIG_fail;
46490 swig_obj[0] = args;
46491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46492 if (!SWIG_IsOK(res1)) {
46493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46494 }
46495 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46496 {
46497 PyThreadState* __tstate = wxPyBeginAllowThreads();
46498 result = (bool)(arg1)->IsWindow();
46499 wxPyEndAllowThreads(__tstate);
46500 if (PyErr_Occurred()) SWIG_fail;
46501 }
46502 {
46503 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46504 }
46505 return resultobj;
46506 fail:
46507 return NULL;
46508 }
46509
46510
46511 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46512 PyObject *resultobj = 0;
46513 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46514 bool result;
46515 void *argp1 = 0 ;
46516 int res1 = 0 ;
46517 PyObject *swig_obj[1] ;
46518
46519 if (!args) SWIG_fail;
46520 swig_obj[0] = args;
46521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46522 if (!SWIG_IsOK(res1)) {
46523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46524 }
46525 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46526 {
46527 PyThreadState* __tstate = wxPyBeginAllowThreads();
46528 result = (bool)(arg1)->IsSizer();
46529 wxPyEndAllowThreads(__tstate);
46530 if (PyErr_Occurred()) SWIG_fail;
46531 }
46532 {
46533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46534 }
46535 return resultobj;
46536 fail:
46537 return NULL;
46538 }
46539
46540
46541 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46542 PyObject *resultobj = 0;
46543 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46544 bool result;
46545 void *argp1 = 0 ;
46546 int res1 = 0 ;
46547 PyObject *swig_obj[1] ;
46548
46549 if (!args) SWIG_fail;
46550 swig_obj[0] = args;
46551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46552 if (!SWIG_IsOK(res1)) {
46553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46554 }
46555 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46556 {
46557 PyThreadState* __tstate = wxPyBeginAllowThreads();
46558 result = (bool)(arg1)->IsSpacer();
46559 wxPyEndAllowThreads(__tstate);
46560 if (PyErr_Occurred()) SWIG_fail;
46561 }
46562 {
46563 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46564 }
46565 return resultobj;
46566 fail:
46567 return NULL;
46568 }
46569
46570
46571 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46572 PyObject *resultobj = 0;
46573 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46574 int arg2 ;
46575 void *argp1 = 0 ;
46576 int res1 = 0 ;
46577 int val2 ;
46578 int ecode2 = 0 ;
46579 PyObject * obj0 = 0 ;
46580 PyObject * obj1 = 0 ;
46581 char * kwnames[] = {
46582 (char *) "self",(char *) "proportion", NULL
46583 };
46584
46585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
46586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46587 if (!SWIG_IsOK(res1)) {
46588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46589 }
46590 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46591 ecode2 = SWIG_AsVal_int(obj1, &val2);
46592 if (!SWIG_IsOK(ecode2)) {
46593 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
46594 }
46595 arg2 = static_cast< int >(val2);
46596 {
46597 PyThreadState* __tstate = wxPyBeginAllowThreads();
46598 (arg1)->SetProportion(arg2);
46599 wxPyEndAllowThreads(__tstate);
46600 if (PyErr_Occurred()) SWIG_fail;
46601 }
46602 resultobj = SWIG_Py_Void();
46603 return resultobj;
46604 fail:
46605 return NULL;
46606 }
46607
46608
46609 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46610 PyObject *resultobj = 0;
46611 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46612 int result;
46613 void *argp1 = 0 ;
46614 int res1 = 0 ;
46615 PyObject *swig_obj[1] ;
46616
46617 if (!args) SWIG_fail;
46618 swig_obj[0] = args;
46619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46620 if (!SWIG_IsOK(res1)) {
46621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46622 }
46623 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46624 {
46625 PyThreadState* __tstate = wxPyBeginAllowThreads();
46626 result = (int)(arg1)->GetProportion();
46627 wxPyEndAllowThreads(__tstate);
46628 if (PyErr_Occurred()) SWIG_fail;
46629 }
46630 resultobj = SWIG_From_int(static_cast< int >(result));
46631 return resultobj;
46632 fail:
46633 return NULL;
46634 }
46635
46636
46637 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46638 PyObject *resultobj = 0;
46639 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46640 int arg2 ;
46641 void *argp1 = 0 ;
46642 int res1 = 0 ;
46643 int val2 ;
46644 int ecode2 = 0 ;
46645 PyObject * obj0 = 0 ;
46646 PyObject * obj1 = 0 ;
46647 char * kwnames[] = {
46648 (char *) "self",(char *) "flag", NULL
46649 };
46650
46651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
46652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46653 if (!SWIG_IsOK(res1)) {
46654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46655 }
46656 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46657 ecode2 = SWIG_AsVal_int(obj1, &val2);
46658 if (!SWIG_IsOK(ecode2)) {
46659 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
46660 }
46661 arg2 = static_cast< int >(val2);
46662 {
46663 PyThreadState* __tstate = wxPyBeginAllowThreads();
46664 (arg1)->SetFlag(arg2);
46665 wxPyEndAllowThreads(__tstate);
46666 if (PyErr_Occurred()) SWIG_fail;
46667 }
46668 resultobj = SWIG_Py_Void();
46669 return resultobj;
46670 fail:
46671 return NULL;
46672 }
46673
46674
46675 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46676 PyObject *resultobj = 0;
46677 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46678 int result;
46679 void *argp1 = 0 ;
46680 int res1 = 0 ;
46681 PyObject *swig_obj[1] ;
46682
46683 if (!args) SWIG_fail;
46684 swig_obj[0] = args;
46685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46686 if (!SWIG_IsOK(res1)) {
46687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46688 }
46689 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46690 {
46691 PyThreadState* __tstate = wxPyBeginAllowThreads();
46692 result = (int)(arg1)->GetFlag();
46693 wxPyEndAllowThreads(__tstate);
46694 if (PyErr_Occurred()) SWIG_fail;
46695 }
46696 resultobj = SWIG_From_int(static_cast< int >(result));
46697 return resultobj;
46698 fail:
46699 return NULL;
46700 }
46701
46702
46703 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46704 PyObject *resultobj = 0;
46705 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46706 int arg2 ;
46707 void *argp1 = 0 ;
46708 int res1 = 0 ;
46709 int val2 ;
46710 int ecode2 = 0 ;
46711 PyObject * obj0 = 0 ;
46712 PyObject * obj1 = 0 ;
46713 char * kwnames[] = {
46714 (char *) "self",(char *) "border", NULL
46715 };
46716
46717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
46718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46719 if (!SWIG_IsOK(res1)) {
46720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46721 }
46722 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46723 ecode2 = SWIG_AsVal_int(obj1, &val2);
46724 if (!SWIG_IsOK(ecode2)) {
46725 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
46726 }
46727 arg2 = static_cast< int >(val2);
46728 {
46729 PyThreadState* __tstate = wxPyBeginAllowThreads();
46730 (arg1)->SetBorder(arg2);
46731 wxPyEndAllowThreads(__tstate);
46732 if (PyErr_Occurred()) SWIG_fail;
46733 }
46734 resultobj = SWIG_Py_Void();
46735 return resultobj;
46736 fail:
46737 return NULL;
46738 }
46739
46740
46741 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46742 PyObject *resultobj = 0;
46743 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46744 int result;
46745 void *argp1 = 0 ;
46746 int res1 = 0 ;
46747 PyObject *swig_obj[1] ;
46748
46749 if (!args) SWIG_fail;
46750 swig_obj[0] = args;
46751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46752 if (!SWIG_IsOK(res1)) {
46753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46754 }
46755 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46756 {
46757 PyThreadState* __tstate = wxPyBeginAllowThreads();
46758 result = (int)(arg1)->GetBorder();
46759 wxPyEndAllowThreads(__tstate);
46760 if (PyErr_Occurred()) SWIG_fail;
46761 }
46762 resultobj = SWIG_From_int(static_cast< int >(result));
46763 return resultobj;
46764 fail:
46765 return NULL;
46766 }
46767
46768
46769 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46770 PyObject *resultobj = 0;
46771 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46772 wxWindow *result = 0 ;
46773 void *argp1 = 0 ;
46774 int res1 = 0 ;
46775 PyObject *swig_obj[1] ;
46776
46777 if (!args) SWIG_fail;
46778 swig_obj[0] = args;
46779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46780 if (!SWIG_IsOK(res1)) {
46781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46782 }
46783 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46784 {
46785 PyThreadState* __tstate = wxPyBeginAllowThreads();
46786 result = (wxWindow *)(arg1)->GetWindow();
46787 wxPyEndAllowThreads(__tstate);
46788 if (PyErr_Occurred()) SWIG_fail;
46789 }
46790 {
46791 resultobj = wxPyMake_wxObject(result, 0);
46792 }
46793 return resultobj;
46794 fail:
46795 return NULL;
46796 }
46797
46798
46799 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46800 PyObject *resultobj = 0;
46801 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46802 wxWindow *arg2 = (wxWindow *) 0 ;
46803 void *argp1 = 0 ;
46804 int res1 = 0 ;
46805 void *argp2 = 0 ;
46806 int res2 = 0 ;
46807 PyObject * obj0 = 0 ;
46808 PyObject * obj1 = 0 ;
46809 char * kwnames[] = {
46810 (char *) "self",(char *) "window", NULL
46811 };
46812
46813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
46814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46815 if (!SWIG_IsOK(res1)) {
46816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46817 }
46818 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46819 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46820 if (!SWIG_IsOK(res2)) {
46821 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
46822 }
46823 arg2 = reinterpret_cast< wxWindow * >(argp2);
46824 {
46825 PyThreadState* __tstate = wxPyBeginAllowThreads();
46826 (arg1)->SetWindow(arg2);
46827 wxPyEndAllowThreads(__tstate);
46828 if (PyErr_Occurred()) SWIG_fail;
46829 }
46830 resultobj = SWIG_Py_Void();
46831 return resultobj;
46832 fail:
46833 return NULL;
46834 }
46835
46836
46837 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46838 PyObject *resultobj = 0;
46839 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46840 wxSizer *result = 0 ;
46841 void *argp1 = 0 ;
46842 int res1 = 0 ;
46843 PyObject *swig_obj[1] ;
46844
46845 if (!args) SWIG_fail;
46846 swig_obj[0] = args;
46847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46848 if (!SWIG_IsOK(res1)) {
46849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46850 }
46851 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46852 {
46853 PyThreadState* __tstate = wxPyBeginAllowThreads();
46854 result = (wxSizer *)(arg1)->GetSizer();
46855 wxPyEndAllowThreads(__tstate);
46856 if (PyErr_Occurred()) SWIG_fail;
46857 }
46858 {
46859 resultobj = wxPyMake_wxObject(result, (bool)0);
46860 }
46861 return resultobj;
46862 fail:
46863 return NULL;
46864 }
46865
46866
46867 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46868 PyObject *resultobj = 0;
46869 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46870 wxSizer *arg2 = (wxSizer *) 0 ;
46871 void *argp1 = 0 ;
46872 int res1 = 0 ;
46873 int res2 = 0 ;
46874 PyObject * obj0 = 0 ;
46875 PyObject * obj1 = 0 ;
46876 char * kwnames[] = {
46877 (char *) "self",(char *) "sizer", NULL
46878 };
46879
46880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
46881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46882 if (!SWIG_IsOK(res1)) {
46883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46884 }
46885 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46886 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46887 if (!SWIG_IsOK(res2)) {
46888 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
46889 }
46890 {
46891 PyThreadState* __tstate = wxPyBeginAllowThreads();
46892 (arg1)->SetSizer(arg2);
46893 wxPyEndAllowThreads(__tstate);
46894 if (PyErr_Occurred()) SWIG_fail;
46895 }
46896 resultobj = SWIG_Py_Void();
46897 return resultobj;
46898 fail:
46899 return NULL;
46900 }
46901
46902
46903 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46904 PyObject *resultobj = 0;
46905 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46906 wxSize *result = 0 ;
46907 void *argp1 = 0 ;
46908 int res1 = 0 ;
46909 PyObject *swig_obj[1] ;
46910
46911 if (!args) SWIG_fail;
46912 swig_obj[0] = args;
46913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46914 if (!SWIG_IsOK(res1)) {
46915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46916 }
46917 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46918 {
46919 PyThreadState* __tstate = wxPyBeginAllowThreads();
46920 {
46921 wxSize const &_result_ref = (arg1)->GetSpacer();
46922 result = (wxSize *) &_result_ref;
46923 }
46924 wxPyEndAllowThreads(__tstate);
46925 if (PyErr_Occurred()) SWIG_fail;
46926 }
46927 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
46928 return resultobj;
46929 fail:
46930 return NULL;
46931 }
46932
46933
46934 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46935 PyObject *resultobj = 0;
46936 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46937 wxSize *arg2 = 0 ;
46938 void *argp1 = 0 ;
46939 int res1 = 0 ;
46940 wxSize temp2 ;
46941 PyObject * obj0 = 0 ;
46942 PyObject * obj1 = 0 ;
46943 char * kwnames[] = {
46944 (char *) "self",(char *) "size", NULL
46945 };
46946
46947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
46948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46949 if (!SWIG_IsOK(res1)) {
46950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46951 }
46952 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46953 {
46954 arg2 = &temp2;
46955 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46956 }
46957 {
46958 PyThreadState* __tstate = wxPyBeginAllowThreads();
46959 (arg1)->SetSpacer((wxSize const &)*arg2);
46960 wxPyEndAllowThreads(__tstate);
46961 if (PyErr_Occurred()) SWIG_fail;
46962 }
46963 resultobj = SWIG_Py_Void();
46964 return resultobj;
46965 fail:
46966 return NULL;
46967 }
46968
46969
46970 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46971 PyObject *resultobj = 0;
46972 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46973 bool arg2 ;
46974 void *argp1 = 0 ;
46975 int res1 = 0 ;
46976 bool val2 ;
46977 int ecode2 = 0 ;
46978 PyObject * obj0 = 0 ;
46979 PyObject * obj1 = 0 ;
46980 char * kwnames[] = {
46981 (char *) "self",(char *) "show", NULL
46982 };
46983
46984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
46985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46986 if (!SWIG_IsOK(res1)) {
46987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46988 }
46989 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46990 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46991 if (!SWIG_IsOK(ecode2)) {
46992 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
46993 }
46994 arg2 = static_cast< bool >(val2);
46995 {
46996 PyThreadState* __tstate = wxPyBeginAllowThreads();
46997 (arg1)->Show(arg2);
46998 wxPyEndAllowThreads(__tstate);
46999 if (PyErr_Occurred()) SWIG_fail;
47000 }
47001 resultobj = SWIG_Py_Void();
47002 return resultobj;
47003 fail:
47004 return NULL;
47005 }
47006
47007
47008 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47009 PyObject *resultobj = 0;
47010 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47011 bool result;
47012 void *argp1 = 0 ;
47013 int res1 = 0 ;
47014 PyObject *swig_obj[1] ;
47015
47016 if (!args) SWIG_fail;
47017 swig_obj[0] = args;
47018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47019 if (!SWIG_IsOK(res1)) {
47020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47021 }
47022 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47023 {
47024 PyThreadState* __tstate = wxPyBeginAllowThreads();
47025 result = (bool)(arg1)->IsShown();
47026 wxPyEndAllowThreads(__tstate);
47027 if (PyErr_Occurred()) SWIG_fail;
47028 }
47029 {
47030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47031 }
47032 return resultobj;
47033 fail:
47034 return NULL;
47035 }
47036
47037
47038 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47039 PyObject *resultobj = 0;
47040 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47041 wxPoint result;
47042 void *argp1 = 0 ;
47043 int res1 = 0 ;
47044 PyObject *swig_obj[1] ;
47045
47046 if (!args) SWIG_fail;
47047 swig_obj[0] = args;
47048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47049 if (!SWIG_IsOK(res1)) {
47050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47051 }
47052 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47053 {
47054 PyThreadState* __tstate = wxPyBeginAllowThreads();
47055 result = (arg1)->GetPosition();
47056 wxPyEndAllowThreads(__tstate);
47057 if (PyErr_Occurred()) SWIG_fail;
47058 }
47059 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
47060 return resultobj;
47061 fail:
47062 return NULL;
47063 }
47064
47065
47066 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47067 PyObject *resultobj = 0;
47068 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47069 PyObject *result = 0 ;
47070 void *argp1 = 0 ;
47071 int res1 = 0 ;
47072 PyObject *swig_obj[1] ;
47073
47074 if (!args) SWIG_fail;
47075 swig_obj[0] = args;
47076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47077 if (!SWIG_IsOK(res1)) {
47078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47079 }
47080 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47081 {
47082 PyThreadState* __tstate = wxPyBeginAllowThreads();
47083 result = (PyObject *)wxSizerItem_GetUserData(arg1);
47084 wxPyEndAllowThreads(__tstate);
47085 if (PyErr_Occurred()) SWIG_fail;
47086 }
47087 resultobj = result;
47088 return resultobj;
47089 fail:
47090 return NULL;
47091 }
47092
47093
47094 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47095 PyObject *resultobj = 0;
47096 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
47097 PyObject *arg2 = (PyObject *) 0 ;
47098 void *argp1 = 0 ;
47099 int res1 = 0 ;
47100 PyObject * obj0 = 0 ;
47101 PyObject * obj1 = 0 ;
47102 char * kwnames[] = {
47103 (char *) "self",(char *) "userData", NULL
47104 };
47105
47106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
47107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47108 if (!SWIG_IsOK(res1)) {
47109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47110 }
47111 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47112 arg2 = obj1;
47113 {
47114 PyThreadState* __tstate = wxPyBeginAllowThreads();
47115 wxSizerItem_SetUserData(arg1,arg2);
47116 wxPyEndAllowThreads(__tstate);
47117 if (PyErr_Occurred()) SWIG_fail;
47118 }
47119 resultobj = SWIG_Py_Void();
47120 return resultobj;
47121 fail:
47122 return NULL;
47123 }
47124
47125
47126 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47127 PyObject *obj;
47128 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47129 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
47130 return SWIG_Py_Void();
47131 }
47132
47133 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47134 return SWIG_Python_InitShadowInstance(args);
47135 }
47136
47137 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47138 PyObject *resultobj = 0;
47139 wxSizer *arg1 = (wxSizer *) 0 ;
47140 void *argp1 = 0 ;
47141 int res1 = 0 ;
47142 PyObject *swig_obj[1] ;
47143
47144 if (!args) SWIG_fail;
47145 swig_obj[0] = args;
47146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
47147 if (!SWIG_IsOK(res1)) {
47148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
47149 }
47150 arg1 = reinterpret_cast< wxSizer * >(argp1);
47151 {
47152 PyThreadState* __tstate = wxPyBeginAllowThreads();
47153 delete arg1;
47154
47155 wxPyEndAllowThreads(__tstate);
47156 if (PyErr_Occurred()) SWIG_fail;
47157 }
47158 resultobj = SWIG_Py_Void();
47159 return resultobj;
47160 fail:
47161 return NULL;
47162 }
47163
47164
47165 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47166 PyObject *resultobj = 0;
47167 wxSizer *arg1 = (wxSizer *) 0 ;
47168 PyObject *arg2 = (PyObject *) 0 ;
47169 void *argp1 = 0 ;
47170 int res1 = 0 ;
47171 PyObject * obj0 = 0 ;
47172 PyObject * obj1 = 0 ;
47173 char * kwnames[] = {
47174 (char *) "self",(char *) "_self", NULL
47175 };
47176
47177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
47178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47179 if (!SWIG_IsOK(res1)) {
47180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
47181 }
47182 arg1 = reinterpret_cast< wxSizer * >(argp1);
47183 arg2 = obj1;
47184 {
47185 PyThreadState* __tstate = wxPyBeginAllowThreads();
47186 wxSizer__setOORInfo(arg1,arg2);
47187 wxPyEndAllowThreads(__tstate);
47188 if (PyErr_Occurred()) SWIG_fail;
47189 }
47190 resultobj = SWIG_Py_Void();
47191 return resultobj;
47192 fail:
47193 return NULL;
47194 }
47195
47196
47197 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47198 PyObject *resultobj = 0;
47199 wxSizer *arg1 = (wxSizer *) 0 ;
47200 PyObject *arg2 = (PyObject *) 0 ;
47201 int arg3 = (int) 0 ;
47202 int arg4 = (int) 0 ;
47203 int arg5 = (int) 0 ;
47204 PyObject *arg6 = (PyObject *) NULL ;
47205 wxSizerItem *result = 0 ;
47206 void *argp1 = 0 ;
47207 int res1 = 0 ;
47208 int val3 ;
47209 int ecode3 = 0 ;
47210 int val4 ;
47211 int ecode4 = 0 ;
47212 int val5 ;
47213 int ecode5 = 0 ;
47214 PyObject * obj0 = 0 ;
47215 PyObject * obj1 = 0 ;
47216 PyObject * obj2 = 0 ;
47217 PyObject * obj3 = 0 ;
47218 PyObject * obj4 = 0 ;
47219 PyObject * obj5 = 0 ;
47220 char * kwnames[] = {
47221 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47222 };
47223
47224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
47225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47226 if (!SWIG_IsOK(res1)) {
47227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
47228 }
47229 arg1 = reinterpret_cast< wxSizer * >(argp1);
47230 arg2 = obj1;
47231 if (obj2) {
47232 ecode3 = SWIG_AsVal_int(obj2, &val3);
47233 if (!SWIG_IsOK(ecode3)) {
47234 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
47235 }
47236 arg3 = static_cast< int >(val3);
47237 }
47238 if (obj3) {
47239 ecode4 = SWIG_AsVal_int(obj3, &val4);
47240 if (!SWIG_IsOK(ecode4)) {
47241 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
47242 }
47243 arg4 = static_cast< int >(val4);
47244 }
47245 if (obj4) {
47246 ecode5 = SWIG_AsVal_int(obj4, &val5);
47247 if (!SWIG_IsOK(ecode5)) {
47248 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
47249 }
47250 arg5 = static_cast< int >(val5);
47251 }
47252 if (obj5) {
47253 arg6 = obj5;
47254 }
47255 {
47256 PyThreadState* __tstate = wxPyBeginAllowThreads();
47257 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
47258 wxPyEndAllowThreads(__tstate);
47259 if (PyErr_Occurred()) SWIG_fail;
47260 }
47261 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47262 return resultobj;
47263 fail:
47264 return NULL;
47265 }
47266
47267
47268 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47269 PyObject *resultobj = 0;
47270 wxSizer *arg1 = (wxSizer *) 0 ;
47271 int arg2 ;
47272 PyObject *arg3 = (PyObject *) 0 ;
47273 int arg4 = (int) 0 ;
47274 int arg5 = (int) 0 ;
47275 int arg6 = (int) 0 ;
47276 PyObject *arg7 = (PyObject *) NULL ;
47277 wxSizerItem *result = 0 ;
47278 void *argp1 = 0 ;
47279 int res1 = 0 ;
47280 int val2 ;
47281 int ecode2 = 0 ;
47282 int val4 ;
47283 int ecode4 = 0 ;
47284 int val5 ;
47285 int ecode5 = 0 ;
47286 int val6 ;
47287 int ecode6 = 0 ;
47288 PyObject * obj0 = 0 ;
47289 PyObject * obj1 = 0 ;
47290 PyObject * obj2 = 0 ;
47291 PyObject * obj3 = 0 ;
47292 PyObject * obj4 = 0 ;
47293 PyObject * obj5 = 0 ;
47294 PyObject * obj6 = 0 ;
47295 char * kwnames[] = {
47296 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47297 };
47298
47299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
47300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47301 if (!SWIG_IsOK(res1)) {
47302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
47303 }
47304 arg1 = reinterpret_cast< wxSizer * >(argp1);
47305 ecode2 = SWIG_AsVal_int(obj1, &val2);
47306 if (!SWIG_IsOK(ecode2)) {
47307 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
47308 }
47309 arg2 = static_cast< int >(val2);
47310 arg3 = obj2;
47311 if (obj3) {
47312 ecode4 = SWIG_AsVal_int(obj3, &val4);
47313 if (!SWIG_IsOK(ecode4)) {
47314 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
47315 }
47316 arg4 = static_cast< int >(val4);
47317 }
47318 if (obj4) {
47319 ecode5 = SWIG_AsVal_int(obj4, &val5);
47320 if (!SWIG_IsOK(ecode5)) {
47321 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
47322 }
47323 arg5 = static_cast< int >(val5);
47324 }
47325 if (obj5) {
47326 ecode6 = SWIG_AsVal_int(obj5, &val6);
47327 if (!SWIG_IsOK(ecode6)) {
47328 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
47329 }
47330 arg6 = static_cast< int >(val6);
47331 }
47332 if (obj6) {
47333 arg7 = obj6;
47334 }
47335 {
47336 PyThreadState* __tstate = wxPyBeginAllowThreads();
47337 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
47338 wxPyEndAllowThreads(__tstate);
47339 if (PyErr_Occurred()) SWIG_fail;
47340 }
47341 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47342 return resultobj;
47343 fail:
47344 return NULL;
47345 }
47346
47347
47348 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47349 PyObject *resultobj = 0;
47350 wxSizer *arg1 = (wxSizer *) 0 ;
47351 PyObject *arg2 = (PyObject *) 0 ;
47352 int arg3 = (int) 0 ;
47353 int arg4 = (int) 0 ;
47354 int arg5 = (int) 0 ;
47355 PyObject *arg6 = (PyObject *) NULL ;
47356 wxSizerItem *result = 0 ;
47357 void *argp1 = 0 ;
47358 int res1 = 0 ;
47359 int val3 ;
47360 int ecode3 = 0 ;
47361 int val4 ;
47362 int ecode4 = 0 ;
47363 int val5 ;
47364 int ecode5 = 0 ;
47365 PyObject * obj0 = 0 ;
47366 PyObject * obj1 = 0 ;
47367 PyObject * obj2 = 0 ;
47368 PyObject * obj3 = 0 ;
47369 PyObject * obj4 = 0 ;
47370 PyObject * obj5 = 0 ;
47371 char * kwnames[] = {
47372 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47373 };
47374
47375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
47376 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47377 if (!SWIG_IsOK(res1)) {
47378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
47379 }
47380 arg1 = reinterpret_cast< wxSizer * >(argp1);
47381 arg2 = obj1;
47382 if (obj2) {
47383 ecode3 = SWIG_AsVal_int(obj2, &val3);
47384 if (!SWIG_IsOK(ecode3)) {
47385 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
47386 }
47387 arg3 = static_cast< int >(val3);
47388 }
47389 if (obj3) {
47390 ecode4 = SWIG_AsVal_int(obj3, &val4);
47391 if (!SWIG_IsOK(ecode4)) {
47392 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
47393 }
47394 arg4 = static_cast< int >(val4);
47395 }
47396 if (obj4) {
47397 ecode5 = SWIG_AsVal_int(obj4, &val5);
47398 if (!SWIG_IsOK(ecode5)) {
47399 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
47400 }
47401 arg5 = static_cast< int >(val5);
47402 }
47403 if (obj5) {
47404 arg6 = obj5;
47405 }
47406 {
47407 PyThreadState* __tstate = wxPyBeginAllowThreads();
47408 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
47409 wxPyEndAllowThreads(__tstate);
47410 if (PyErr_Occurred()) SWIG_fail;
47411 }
47412 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47413 return resultobj;
47414 fail:
47415 return NULL;
47416 }
47417
47418
47419 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47420 PyObject *resultobj = 0;
47421 wxSizer *arg1 = (wxSizer *) 0 ;
47422 PyObject *arg2 = (PyObject *) 0 ;
47423 bool result;
47424 void *argp1 = 0 ;
47425 int res1 = 0 ;
47426 PyObject * obj0 = 0 ;
47427 PyObject * obj1 = 0 ;
47428 char * kwnames[] = {
47429 (char *) "self",(char *) "item", NULL
47430 };
47431
47432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
47433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47434 if (!SWIG_IsOK(res1)) {
47435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
47436 }
47437 arg1 = reinterpret_cast< wxSizer * >(argp1);
47438 arg2 = obj1;
47439 {
47440 PyThreadState* __tstate = wxPyBeginAllowThreads();
47441 result = (bool)wxSizer_Remove(arg1,arg2);
47442 wxPyEndAllowThreads(__tstate);
47443 if (PyErr_Occurred()) SWIG_fail;
47444 }
47445 {
47446 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47447 }
47448 return resultobj;
47449 fail:
47450 return NULL;
47451 }
47452
47453
47454 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47455 PyObject *resultobj = 0;
47456 wxSizer *arg1 = (wxSizer *) 0 ;
47457 PyObject *arg2 = (PyObject *) 0 ;
47458 bool result;
47459 void *argp1 = 0 ;
47460 int res1 = 0 ;
47461 PyObject * obj0 = 0 ;
47462 PyObject * obj1 = 0 ;
47463 char * kwnames[] = {
47464 (char *) "self",(char *) "item", NULL
47465 };
47466
47467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
47468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47469 if (!SWIG_IsOK(res1)) {
47470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
47471 }
47472 arg1 = reinterpret_cast< wxSizer * >(argp1);
47473 arg2 = obj1;
47474 {
47475 PyThreadState* __tstate = wxPyBeginAllowThreads();
47476 result = (bool)wxSizer_Detach(arg1,arg2);
47477 wxPyEndAllowThreads(__tstate);
47478 if (PyErr_Occurred()) SWIG_fail;
47479 }
47480 {
47481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47482 }
47483 return resultobj;
47484 fail:
47485 return NULL;
47486 }
47487
47488
47489 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47490 PyObject *resultobj = 0;
47491 wxSizer *arg1 = (wxSizer *) 0 ;
47492 PyObject *arg2 = (PyObject *) 0 ;
47493 wxSizerItem *result = 0 ;
47494 void *argp1 = 0 ;
47495 int res1 = 0 ;
47496 PyObject * obj0 = 0 ;
47497 PyObject * obj1 = 0 ;
47498 char * kwnames[] = {
47499 (char *) "self",(char *) "item", NULL
47500 };
47501
47502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
47503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47504 if (!SWIG_IsOK(res1)) {
47505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47506 }
47507 arg1 = reinterpret_cast< wxSizer * >(argp1);
47508 arg2 = obj1;
47509 {
47510 PyThreadState* __tstate = wxPyBeginAllowThreads();
47511 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
47512 wxPyEndAllowThreads(__tstate);
47513 if (PyErr_Occurred()) SWIG_fail;
47514 }
47515 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47516 return resultobj;
47517 fail:
47518 return NULL;
47519 }
47520
47521
47522 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47523 PyObject *resultobj = 0;
47524 wxSizer *arg1 = (wxSizer *) 0 ;
47525 PyObject *arg2 = (PyObject *) 0 ;
47526 wxSize *arg3 = 0 ;
47527 void *argp1 = 0 ;
47528 int res1 = 0 ;
47529 wxSize temp3 ;
47530 PyObject * obj0 = 0 ;
47531 PyObject * obj1 = 0 ;
47532 PyObject * obj2 = 0 ;
47533 char * kwnames[] = {
47534 (char *) "self",(char *) "item",(char *) "size", NULL
47535 };
47536
47537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47539 if (!SWIG_IsOK(res1)) {
47540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47541 }
47542 arg1 = reinterpret_cast< wxSizer * >(argp1);
47543 arg2 = obj1;
47544 {
47545 arg3 = &temp3;
47546 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
47547 }
47548 {
47549 PyThreadState* __tstate = wxPyBeginAllowThreads();
47550 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
47551 wxPyEndAllowThreads(__tstate);
47552 if (PyErr_Occurred()) SWIG_fail;
47553 }
47554 resultobj = SWIG_Py_Void();
47555 return resultobj;
47556 fail:
47557 return NULL;
47558 }
47559
47560
47561 SWIGINTERN PyObject *_wrap_Sizer__ReplaceWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47562 PyObject *resultobj = 0;
47563 wxSizer *arg1 = (wxSizer *) 0 ;
47564 wxWindow *arg2 = (wxWindow *) 0 ;
47565 wxWindow *arg3 = (wxWindow *) 0 ;
47566 bool arg4 = (bool) false ;
47567 bool result;
47568 void *argp1 = 0 ;
47569 int res1 = 0 ;
47570 void *argp2 = 0 ;
47571 int res2 = 0 ;
47572 void *argp3 = 0 ;
47573 int res3 = 0 ;
47574 bool val4 ;
47575 int ecode4 = 0 ;
47576 PyObject * obj0 = 0 ;
47577 PyObject * obj1 = 0 ;
47578 PyObject * obj2 = 0 ;
47579 PyObject * obj3 = 0 ;
47580 char * kwnames[] = {
47581 (char *) "self",(char *) "oldwin",(char *) "newwin",(char *) "recursive", NULL
47582 };
47583
47584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceWin",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47585 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47586 if (!SWIG_IsOK(res1)) {
47587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceWin" "', expected argument " "1"" of type '" "wxSizer *""'");
47588 }
47589 arg1 = reinterpret_cast< wxSizer * >(argp1);
47590 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47591 if (!SWIG_IsOK(res2)) {
47592 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceWin" "', expected argument " "2"" of type '" "wxWindow *""'");
47593 }
47594 arg2 = reinterpret_cast< wxWindow * >(argp2);
47595 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
47596 if (!SWIG_IsOK(res3)) {
47597 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceWin" "', expected argument " "3"" of type '" "wxWindow *""'");
47598 }
47599 arg3 = reinterpret_cast< wxWindow * >(argp3);
47600 if (obj3) {
47601 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47602 if (!SWIG_IsOK(ecode4)) {
47603 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceWin" "', expected argument " "4"" of type '" "bool""'");
47604 }
47605 arg4 = static_cast< bool >(val4);
47606 }
47607 {
47608 PyThreadState* __tstate = wxPyBeginAllowThreads();
47609 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
47610 wxPyEndAllowThreads(__tstate);
47611 if (PyErr_Occurred()) SWIG_fail;
47612 }
47613 {
47614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47615 }
47616 return resultobj;
47617 fail:
47618 return NULL;
47619 }
47620
47621
47622 SWIGINTERN PyObject *_wrap_Sizer__ReplaceSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47623 PyObject *resultobj = 0;
47624 wxSizer *arg1 = (wxSizer *) 0 ;
47625 wxSizer *arg2 = (wxSizer *) 0 ;
47626 wxSizer *arg3 = (wxSizer *) 0 ;
47627 bool arg4 = (bool) false ;
47628 bool result;
47629 void *argp1 = 0 ;
47630 int res1 = 0 ;
47631 void *argp2 = 0 ;
47632 int res2 = 0 ;
47633 void *argp3 = 0 ;
47634 int res3 = 0 ;
47635 bool val4 ;
47636 int ecode4 = 0 ;
47637 PyObject * obj0 = 0 ;
47638 PyObject * obj1 = 0 ;
47639 PyObject * obj2 = 0 ;
47640 PyObject * obj3 = 0 ;
47641 char * kwnames[] = {
47642 (char *) "self",(char *) "oldsz",(char *) "newsz",(char *) "recursive", NULL
47643 };
47644
47645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47647 if (!SWIG_IsOK(res1)) {
47648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
47649 }
47650 arg1 = reinterpret_cast< wxSizer * >(argp1);
47651 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
47652 if (!SWIG_IsOK(res2)) {
47653 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
47654 }
47655 arg2 = reinterpret_cast< wxSizer * >(argp2);
47656 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizer, 0 | 0 );
47657 if (!SWIG_IsOK(res3)) {
47658 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceSizer" "', expected argument " "3"" of type '" "wxSizer *""'");
47659 }
47660 arg3 = reinterpret_cast< wxSizer * >(argp3);
47661 if (obj3) {
47662 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47663 if (!SWIG_IsOK(ecode4)) {
47664 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceSizer" "', expected argument " "4"" of type '" "bool""'");
47665 }
47666 arg4 = static_cast< bool >(val4);
47667 }
47668 {
47669 PyThreadState* __tstate = wxPyBeginAllowThreads();
47670 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
47671 wxPyEndAllowThreads(__tstate);
47672 if (PyErr_Occurred()) SWIG_fail;
47673 }
47674 {
47675 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47676 }
47677 return resultobj;
47678 fail:
47679 return NULL;
47680 }
47681
47682
47683 SWIGINTERN PyObject *_wrap_Sizer__ReplaceItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47684 PyObject *resultobj = 0;
47685 wxSizer *arg1 = (wxSizer *) 0 ;
47686 size_t arg2 ;
47687 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
47688 bool result;
47689 void *argp1 = 0 ;
47690 int res1 = 0 ;
47691 size_t val2 ;
47692 int ecode2 = 0 ;
47693 void *argp3 = 0 ;
47694 int res3 = 0 ;
47695 PyObject * obj0 = 0 ;
47696 PyObject * obj1 = 0 ;
47697 PyObject * obj2 = 0 ;
47698 char * kwnames[] = {
47699 (char *) "self",(char *) "index",(char *) "newitem", NULL
47700 };
47701
47702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__ReplaceItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47704 if (!SWIG_IsOK(res1)) {
47705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47706 }
47707 arg1 = reinterpret_cast< wxSizer * >(argp1);
47708 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47709 if (!SWIG_IsOK(ecode2)) {
47710 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer__ReplaceItem" "', expected argument " "2"" of type '" "size_t""'");
47711 }
47712 arg2 = static_cast< size_t >(val2);
47713 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47714 if (!SWIG_IsOK(res3)) {
47715 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
47716 }
47717 arg3 = reinterpret_cast< wxSizerItem * >(argp3);
47718 {
47719 PyThreadState* __tstate = wxPyBeginAllowThreads();
47720 result = (bool)(arg1)->Replace(arg2,arg3);
47721 wxPyEndAllowThreads(__tstate);
47722 if (PyErr_Occurred()) SWIG_fail;
47723 }
47724 {
47725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47726 }
47727 return resultobj;
47728 fail:
47729 return NULL;
47730 }
47731
47732
47733 SWIGINTERN PyObject *_wrap_Sizer_SetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47734 PyObject *resultobj = 0;
47735 wxSizer *arg1 = (wxSizer *) 0 ;
47736 wxWindow *arg2 = (wxWindow *) 0 ;
47737 void *argp1 = 0 ;
47738 int res1 = 0 ;
47739 void *argp2 = 0 ;
47740 int res2 = 0 ;
47741 PyObject * obj0 = 0 ;
47742 PyObject * obj1 = 0 ;
47743 char * kwnames[] = {
47744 (char *) "self",(char *) "window", NULL
47745 };
47746
47747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetContainingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
47748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47749 if (!SWIG_IsOK(res1)) {
47750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetContainingWindow" "', expected argument " "1"" of type '" "wxSizer *""'");
47751 }
47752 arg1 = reinterpret_cast< wxSizer * >(argp1);
47753 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47754 if (!SWIG_IsOK(res2)) {
47755 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetContainingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
47756 }
47757 arg2 = reinterpret_cast< wxWindow * >(argp2);
47758 {
47759 PyThreadState* __tstate = wxPyBeginAllowThreads();
47760 (arg1)->SetContainingWindow(arg2);
47761 wxPyEndAllowThreads(__tstate);
47762 if (PyErr_Occurred()) SWIG_fail;
47763 }
47764 resultobj = SWIG_Py_Void();
47765 return resultobj;
47766 fail:
47767 return NULL;
47768 }
47769
47770
47771 SWIGINTERN PyObject *_wrap_Sizer_GetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47772 PyObject *resultobj = 0;
47773 wxSizer *arg1 = (wxSizer *) 0 ;
47774 wxWindow *result = 0 ;
47775 void *argp1 = 0 ;
47776 int res1 = 0 ;
47777 PyObject *swig_obj[1] ;
47778
47779 if (!args) SWIG_fail;
47780 swig_obj[0] = args;
47781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47782 if (!SWIG_IsOK(res1)) {
47783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetContainingWindow" "', expected argument " "1"" of type '" "wxSizer const *""'");
47784 }
47785 arg1 = reinterpret_cast< wxSizer * >(argp1);
47786 {
47787 PyThreadState* __tstate = wxPyBeginAllowThreads();
47788 result = (wxWindow *)((wxSizer const *)arg1)->GetContainingWindow();
47789 wxPyEndAllowThreads(__tstate);
47790 if (PyErr_Occurred()) SWIG_fail;
47791 }
47792 {
47793 resultobj = wxPyMake_wxObject(result, 0);
47794 }
47795 return resultobj;
47796 fail:
47797 return NULL;
47798 }
47799
47800
47801 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47802 PyObject *resultobj = 0;
47803 wxSizer *arg1 = (wxSizer *) 0 ;
47804 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
47805 wxSizerItem *result = 0 ;
47806 void *argp1 = 0 ;
47807 int res1 = 0 ;
47808 int res2 = 0 ;
47809 PyObject * obj0 = 0 ;
47810 PyObject * obj1 = 0 ;
47811 char * kwnames[] = {
47812 (char *) "self",(char *) "item", NULL
47813 };
47814
47815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
47816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47817 if (!SWIG_IsOK(res1)) {
47818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47819 }
47820 arg1 = reinterpret_cast< wxSizer * >(argp1);
47821 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47822 if (!SWIG_IsOK(res2)) {
47823 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
47824 }
47825 {
47826 PyThreadState* __tstate = wxPyBeginAllowThreads();
47827 result = (wxSizerItem *)(arg1)->Add(arg2);
47828 wxPyEndAllowThreads(__tstate);
47829 if (PyErr_Occurred()) SWIG_fail;
47830 }
47831 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47832 return resultobj;
47833 fail:
47834 return NULL;
47835 }
47836
47837
47838 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47839 PyObject *resultobj = 0;
47840 wxSizer *arg1 = (wxSizer *) 0 ;
47841 size_t arg2 ;
47842 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
47843 wxSizerItem *result = 0 ;
47844 void *argp1 = 0 ;
47845 int res1 = 0 ;
47846 size_t val2 ;
47847 int ecode2 = 0 ;
47848 int res3 = 0 ;
47849 PyObject * obj0 = 0 ;
47850 PyObject * obj1 = 0 ;
47851 PyObject * obj2 = 0 ;
47852 char * kwnames[] = {
47853 (char *) "self",(char *) "index",(char *) "item", NULL
47854 };
47855
47856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47858 if (!SWIG_IsOK(res1)) {
47859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47860 }
47861 arg1 = reinterpret_cast< wxSizer * >(argp1);
47862 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47863 if (!SWIG_IsOK(ecode2)) {
47864 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
47865 }
47866 arg2 = static_cast< size_t >(val2);
47867 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47868 if (!SWIG_IsOK(res3)) {
47869 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
47870 }
47871 {
47872 PyThreadState* __tstate = wxPyBeginAllowThreads();
47873 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
47874 wxPyEndAllowThreads(__tstate);
47875 if (PyErr_Occurred()) SWIG_fail;
47876 }
47877 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47878 return resultobj;
47879 fail:
47880 return NULL;
47881 }
47882
47883
47884 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47885 PyObject *resultobj = 0;
47886 wxSizer *arg1 = (wxSizer *) 0 ;
47887 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
47888 wxSizerItem *result = 0 ;
47889 void *argp1 = 0 ;
47890 int res1 = 0 ;
47891 int res2 = 0 ;
47892 PyObject * obj0 = 0 ;
47893 PyObject * obj1 = 0 ;
47894 char * kwnames[] = {
47895 (char *) "self",(char *) "item", NULL
47896 };
47897
47898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
47899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47900 if (!SWIG_IsOK(res1)) {
47901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47902 }
47903 arg1 = reinterpret_cast< wxSizer * >(argp1);
47904 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47905 if (!SWIG_IsOK(res2)) {
47906 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
47907 }
47908 {
47909 PyThreadState* __tstate = wxPyBeginAllowThreads();
47910 result = (wxSizerItem *)(arg1)->Prepend(arg2);
47911 wxPyEndAllowThreads(__tstate);
47912 if (PyErr_Occurred()) SWIG_fail;
47913 }
47914 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47915 return resultobj;
47916 fail:
47917 return NULL;
47918 }
47919
47920
47921 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47922 PyObject *resultobj = 0;
47923 wxSizer *arg1 = (wxSizer *) 0 ;
47924 int arg2 ;
47925 int arg3 ;
47926 int arg4 ;
47927 int arg5 ;
47928 void *argp1 = 0 ;
47929 int res1 = 0 ;
47930 int val2 ;
47931 int ecode2 = 0 ;
47932 int val3 ;
47933 int ecode3 = 0 ;
47934 int val4 ;
47935 int ecode4 = 0 ;
47936 int val5 ;
47937 int ecode5 = 0 ;
47938 PyObject * obj0 = 0 ;
47939 PyObject * obj1 = 0 ;
47940 PyObject * obj2 = 0 ;
47941 PyObject * obj3 = 0 ;
47942 PyObject * obj4 = 0 ;
47943 char * kwnames[] = {
47944 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
47945 };
47946
47947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
47948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47949 if (!SWIG_IsOK(res1)) {
47950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
47951 }
47952 arg1 = reinterpret_cast< wxSizer * >(argp1);
47953 ecode2 = SWIG_AsVal_int(obj1, &val2);
47954 if (!SWIG_IsOK(ecode2)) {
47955 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
47956 }
47957 arg2 = static_cast< int >(val2);
47958 ecode3 = SWIG_AsVal_int(obj2, &val3);
47959 if (!SWIG_IsOK(ecode3)) {
47960 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
47961 }
47962 arg3 = static_cast< int >(val3);
47963 ecode4 = SWIG_AsVal_int(obj3, &val4);
47964 if (!SWIG_IsOK(ecode4)) {
47965 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
47966 }
47967 arg4 = static_cast< int >(val4);
47968 ecode5 = SWIG_AsVal_int(obj4, &val5);
47969 if (!SWIG_IsOK(ecode5)) {
47970 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
47971 }
47972 arg5 = static_cast< int >(val5);
47973 {
47974 PyThreadState* __tstate = wxPyBeginAllowThreads();
47975 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
47976 wxPyEndAllowThreads(__tstate);
47977 if (PyErr_Occurred()) SWIG_fail;
47978 }
47979 resultobj = SWIG_Py_Void();
47980 return resultobj;
47981 fail:
47982 return NULL;
47983 }
47984
47985
47986 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47987 PyObject *resultobj = 0;
47988 wxSizer *arg1 = (wxSizer *) 0 ;
47989 wxSize *arg2 = 0 ;
47990 void *argp1 = 0 ;
47991 int res1 = 0 ;
47992 wxSize temp2 ;
47993 PyObject * obj0 = 0 ;
47994 PyObject * obj1 = 0 ;
47995 char * kwnames[] = {
47996 (char *) "self",(char *) "size", NULL
47997 };
47998
47999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
48000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48001 if (!SWIG_IsOK(res1)) {
48002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
48003 }
48004 arg1 = reinterpret_cast< wxSizer * >(argp1);
48005 {
48006 arg2 = &temp2;
48007 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
48008 }
48009 {
48010 PyThreadState* __tstate = wxPyBeginAllowThreads();
48011 (arg1)->SetMinSize((wxSize const &)*arg2);
48012 wxPyEndAllowThreads(__tstate);
48013 if (PyErr_Occurred()) SWIG_fail;
48014 }
48015 resultobj = SWIG_Py_Void();
48016 return resultobj;
48017 fail:
48018 return NULL;
48019 }
48020
48021
48022 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48023 PyObject *resultobj = 0;
48024 wxSizer *arg1 = (wxSizer *) 0 ;
48025 wxSize result;
48026 void *argp1 = 0 ;
48027 int res1 = 0 ;
48028 PyObject *swig_obj[1] ;
48029
48030 if (!args) SWIG_fail;
48031 swig_obj[0] = args;
48032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48033 if (!SWIG_IsOK(res1)) {
48034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
48035 }
48036 arg1 = reinterpret_cast< wxSizer * >(argp1);
48037 {
48038 PyThreadState* __tstate = wxPyBeginAllowThreads();
48039 result = (arg1)->GetSize();
48040 wxPyEndAllowThreads(__tstate);
48041 if (PyErr_Occurred()) SWIG_fail;
48042 }
48043 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48044 return resultobj;
48045 fail:
48046 return NULL;
48047 }
48048
48049
48050 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48051 PyObject *resultobj = 0;
48052 wxSizer *arg1 = (wxSizer *) 0 ;
48053 wxPoint result;
48054 void *argp1 = 0 ;
48055 int res1 = 0 ;
48056 PyObject *swig_obj[1] ;
48057
48058 if (!args) SWIG_fail;
48059 swig_obj[0] = args;
48060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48061 if (!SWIG_IsOK(res1)) {
48062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
48063 }
48064 arg1 = reinterpret_cast< wxSizer * >(argp1);
48065 {
48066 PyThreadState* __tstate = wxPyBeginAllowThreads();
48067 result = (arg1)->GetPosition();
48068 wxPyEndAllowThreads(__tstate);
48069 if (PyErr_Occurred()) SWIG_fail;
48070 }
48071 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
48072 return resultobj;
48073 fail:
48074 return NULL;
48075 }
48076
48077
48078 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48079 PyObject *resultobj = 0;
48080 wxSizer *arg1 = (wxSizer *) 0 ;
48081 wxSize result;
48082 void *argp1 = 0 ;
48083 int res1 = 0 ;
48084 PyObject *swig_obj[1] ;
48085
48086 if (!args) SWIG_fail;
48087 swig_obj[0] = args;
48088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48089 if (!SWIG_IsOK(res1)) {
48090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
48091 }
48092 arg1 = reinterpret_cast< wxSizer * >(argp1);
48093 {
48094 PyThreadState* __tstate = wxPyBeginAllowThreads();
48095 result = (arg1)->GetMinSize();
48096 wxPyEndAllowThreads(__tstate);
48097 if (PyErr_Occurred()) SWIG_fail;
48098 }
48099 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48100 return resultobj;
48101 fail:
48102 return NULL;
48103 }
48104
48105
48106 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48107 PyObject *resultobj = 0;
48108 wxSizer *arg1 = (wxSizer *) 0 ;
48109 void *argp1 = 0 ;
48110 int res1 = 0 ;
48111 PyObject *swig_obj[1] ;
48112
48113 if (!args) SWIG_fail;
48114 swig_obj[0] = args;
48115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48116 if (!SWIG_IsOK(res1)) {
48117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
48118 }
48119 arg1 = reinterpret_cast< wxSizer * >(argp1);
48120 {
48121 PyThreadState* __tstate = wxPyBeginAllowThreads();
48122 (arg1)->RecalcSizes();
48123 wxPyEndAllowThreads(__tstate);
48124 if (PyErr_Occurred()) SWIG_fail;
48125 }
48126 resultobj = SWIG_Py_Void();
48127 return resultobj;
48128 fail:
48129 return NULL;
48130 }
48131
48132
48133 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48134 PyObject *resultobj = 0;
48135 wxSizer *arg1 = (wxSizer *) 0 ;
48136 wxSize result;
48137 void *argp1 = 0 ;
48138 int res1 = 0 ;
48139 PyObject *swig_obj[1] ;
48140
48141 if (!args) SWIG_fail;
48142 swig_obj[0] = args;
48143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48144 if (!SWIG_IsOK(res1)) {
48145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
48146 }
48147 arg1 = reinterpret_cast< wxSizer * >(argp1);
48148 {
48149 PyThreadState* __tstate = wxPyBeginAllowThreads();
48150 result = (arg1)->CalcMin();
48151 wxPyEndAllowThreads(__tstate);
48152 if (PyErr_Occurred()) SWIG_fail;
48153 }
48154 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48155 return resultobj;
48156 fail:
48157 return NULL;
48158 }
48159
48160
48161 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48162 PyObject *resultobj = 0;
48163 wxSizer *arg1 = (wxSizer *) 0 ;
48164 void *argp1 = 0 ;
48165 int res1 = 0 ;
48166 PyObject *swig_obj[1] ;
48167
48168 if (!args) SWIG_fail;
48169 swig_obj[0] = args;
48170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48171 if (!SWIG_IsOK(res1)) {
48172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
48173 }
48174 arg1 = reinterpret_cast< wxSizer * >(argp1);
48175 {
48176 PyThreadState* __tstate = wxPyBeginAllowThreads();
48177 (arg1)->Layout();
48178 wxPyEndAllowThreads(__tstate);
48179 if (PyErr_Occurred()) SWIG_fail;
48180 }
48181 resultobj = SWIG_Py_Void();
48182 return resultobj;
48183 fail:
48184 return NULL;
48185 }
48186
48187
48188 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48189 PyObject *resultobj = 0;
48190 wxSizer *arg1 = (wxSizer *) 0 ;
48191 wxWindow *arg2 = (wxWindow *) 0 ;
48192 wxSize result;
48193 void *argp1 = 0 ;
48194 int res1 = 0 ;
48195 void *argp2 = 0 ;
48196 int res2 = 0 ;
48197 PyObject * obj0 = 0 ;
48198 PyObject * obj1 = 0 ;
48199 char * kwnames[] = {
48200 (char *) "self",(char *) "window", NULL
48201 };
48202
48203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
48204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48205 if (!SWIG_IsOK(res1)) {
48206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
48207 }
48208 arg1 = reinterpret_cast< wxSizer * >(argp1);
48209 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48210 if (!SWIG_IsOK(res2)) {
48211 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
48212 }
48213 arg2 = reinterpret_cast< wxWindow * >(argp2);
48214 {
48215 PyThreadState* __tstate = wxPyBeginAllowThreads();
48216 result = (arg1)->Fit(arg2);
48217 wxPyEndAllowThreads(__tstate);
48218 if (PyErr_Occurred()) SWIG_fail;
48219 }
48220 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48221 return resultobj;
48222 fail:
48223 return NULL;
48224 }
48225
48226
48227 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48228 PyObject *resultobj = 0;
48229 wxSizer *arg1 = (wxSizer *) 0 ;
48230 wxWindow *arg2 = (wxWindow *) 0 ;
48231 void *argp1 = 0 ;
48232 int res1 = 0 ;
48233 void *argp2 = 0 ;
48234 int res2 = 0 ;
48235 PyObject * obj0 = 0 ;
48236 PyObject * obj1 = 0 ;
48237 char * kwnames[] = {
48238 (char *) "self",(char *) "window", NULL
48239 };
48240
48241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
48242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48243 if (!SWIG_IsOK(res1)) {
48244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
48245 }
48246 arg1 = reinterpret_cast< wxSizer * >(argp1);
48247 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48248 if (!SWIG_IsOK(res2)) {
48249 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
48250 }
48251 arg2 = reinterpret_cast< wxWindow * >(argp2);
48252 {
48253 PyThreadState* __tstate = wxPyBeginAllowThreads();
48254 (arg1)->FitInside(arg2);
48255 wxPyEndAllowThreads(__tstate);
48256 if (PyErr_Occurred()) SWIG_fail;
48257 }
48258 resultobj = SWIG_Py_Void();
48259 return resultobj;
48260 fail:
48261 return NULL;
48262 }
48263
48264
48265 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48266 PyObject *resultobj = 0;
48267 wxSizer *arg1 = (wxSizer *) 0 ;
48268 wxWindow *arg2 = (wxWindow *) 0 ;
48269 void *argp1 = 0 ;
48270 int res1 = 0 ;
48271 void *argp2 = 0 ;
48272 int res2 = 0 ;
48273 PyObject * obj0 = 0 ;
48274 PyObject * obj1 = 0 ;
48275 char * kwnames[] = {
48276 (char *) "self",(char *) "window", NULL
48277 };
48278
48279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
48280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48281 if (!SWIG_IsOK(res1)) {
48282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
48283 }
48284 arg1 = reinterpret_cast< wxSizer * >(argp1);
48285 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48286 if (!SWIG_IsOK(res2)) {
48287 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
48288 }
48289 arg2 = reinterpret_cast< wxWindow * >(argp2);
48290 {
48291 PyThreadState* __tstate = wxPyBeginAllowThreads();
48292 (arg1)->SetSizeHints(arg2);
48293 wxPyEndAllowThreads(__tstate);
48294 if (PyErr_Occurred()) SWIG_fail;
48295 }
48296 resultobj = SWIG_Py_Void();
48297 return resultobj;
48298 fail:
48299 return NULL;
48300 }
48301
48302
48303 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48304 PyObject *resultobj = 0;
48305 wxSizer *arg1 = (wxSizer *) 0 ;
48306 wxWindow *arg2 = (wxWindow *) 0 ;
48307 void *argp1 = 0 ;
48308 int res1 = 0 ;
48309 void *argp2 = 0 ;
48310 int res2 = 0 ;
48311 PyObject * obj0 = 0 ;
48312 PyObject * obj1 = 0 ;
48313 char * kwnames[] = {
48314 (char *) "self",(char *) "window", NULL
48315 };
48316
48317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
48318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48319 if (!SWIG_IsOK(res1)) {
48320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
48321 }
48322 arg1 = reinterpret_cast< wxSizer * >(argp1);
48323 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48324 if (!SWIG_IsOK(res2)) {
48325 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
48326 }
48327 arg2 = reinterpret_cast< wxWindow * >(argp2);
48328 {
48329 PyThreadState* __tstate = wxPyBeginAllowThreads();
48330 (arg1)->SetVirtualSizeHints(arg2);
48331 wxPyEndAllowThreads(__tstate);
48332 if (PyErr_Occurred()) SWIG_fail;
48333 }
48334 resultobj = SWIG_Py_Void();
48335 return resultobj;
48336 fail:
48337 return NULL;
48338 }
48339
48340
48341 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48342 PyObject *resultobj = 0;
48343 wxSizer *arg1 = (wxSizer *) 0 ;
48344 bool arg2 = (bool) false ;
48345 void *argp1 = 0 ;
48346 int res1 = 0 ;
48347 bool val2 ;
48348 int ecode2 = 0 ;
48349 PyObject * obj0 = 0 ;
48350 PyObject * obj1 = 0 ;
48351 char * kwnames[] = {
48352 (char *) "self",(char *) "deleteWindows", NULL
48353 };
48354
48355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
48356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48357 if (!SWIG_IsOK(res1)) {
48358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
48359 }
48360 arg1 = reinterpret_cast< wxSizer * >(argp1);
48361 if (obj1) {
48362 ecode2 = SWIG_AsVal_bool(obj1, &val2);
48363 if (!SWIG_IsOK(ecode2)) {
48364 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
48365 }
48366 arg2 = static_cast< bool >(val2);
48367 }
48368 {
48369 PyThreadState* __tstate = wxPyBeginAllowThreads();
48370 (arg1)->Clear(arg2);
48371 wxPyEndAllowThreads(__tstate);
48372 if (PyErr_Occurred()) SWIG_fail;
48373 }
48374 resultobj = SWIG_Py_Void();
48375 return resultobj;
48376 fail:
48377 return NULL;
48378 }
48379
48380
48381 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48382 PyObject *resultobj = 0;
48383 wxSizer *arg1 = (wxSizer *) 0 ;
48384 void *argp1 = 0 ;
48385 int res1 = 0 ;
48386 PyObject *swig_obj[1] ;
48387
48388 if (!args) SWIG_fail;
48389 swig_obj[0] = args;
48390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48391 if (!SWIG_IsOK(res1)) {
48392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
48393 }
48394 arg1 = reinterpret_cast< wxSizer * >(argp1);
48395 {
48396 PyThreadState* __tstate = wxPyBeginAllowThreads();
48397 (arg1)->DeleteWindows();
48398 wxPyEndAllowThreads(__tstate);
48399 if (PyErr_Occurred()) SWIG_fail;
48400 }
48401 resultobj = SWIG_Py_Void();
48402 return resultobj;
48403 fail:
48404 return NULL;
48405 }
48406
48407
48408 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48409 PyObject *resultobj = 0;
48410 wxSizer *arg1 = (wxSizer *) 0 ;
48411 PyObject *result = 0 ;
48412 void *argp1 = 0 ;
48413 int res1 = 0 ;
48414 PyObject *swig_obj[1] ;
48415
48416 if (!args) SWIG_fail;
48417 swig_obj[0] = args;
48418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48419 if (!SWIG_IsOK(res1)) {
48420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
48421 }
48422 arg1 = reinterpret_cast< wxSizer * >(argp1);
48423 {
48424 PyThreadState* __tstate = wxPyBeginAllowThreads();
48425 result = (PyObject *)wxSizer_GetChildren(arg1);
48426 wxPyEndAllowThreads(__tstate);
48427 if (PyErr_Occurred()) SWIG_fail;
48428 }
48429 resultobj = result;
48430 return resultobj;
48431 fail:
48432 return NULL;
48433 }
48434
48435
48436 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48437 PyObject *resultobj = 0;
48438 wxSizer *arg1 = (wxSizer *) 0 ;
48439 PyObject *arg2 = (PyObject *) 0 ;
48440 bool arg3 = (bool) true ;
48441 bool arg4 = (bool) false ;
48442 bool result;
48443 void *argp1 = 0 ;
48444 int res1 = 0 ;
48445 bool val3 ;
48446 int ecode3 = 0 ;
48447 bool val4 ;
48448 int ecode4 = 0 ;
48449 PyObject * obj0 = 0 ;
48450 PyObject * obj1 = 0 ;
48451 PyObject * obj2 = 0 ;
48452 PyObject * obj3 = 0 ;
48453 char * kwnames[] = {
48454 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
48455 };
48456
48457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48459 if (!SWIG_IsOK(res1)) {
48460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
48461 }
48462 arg1 = reinterpret_cast< wxSizer * >(argp1);
48463 arg2 = obj1;
48464 if (obj2) {
48465 ecode3 = SWIG_AsVal_bool(obj2, &val3);
48466 if (!SWIG_IsOK(ecode3)) {
48467 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
48468 }
48469 arg3 = static_cast< bool >(val3);
48470 }
48471 if (obj3) {
48472 ecode4 = SWIG_AsVal_bool(obj3, &val4);
48473 if (!SWIG_IsOK(ecode4)) {
48474 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
48475 }
48476 arg4 = static_cast< bool >(val4);
48477 }
48478 {
48479 PyThreadState* __tstate = wxPyBeginAllowThreads();
48480 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
48481 wxPyEndAllowThreads(__tstate);
48482 if (PyErr_Occurred()) SWIG_fail;
48483 }
48484 {
48485 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48486 }
48487 return resultobj;
48488 fail:
48489 return NULL;
48490 }
48491
48492
48493 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48494 PyObject *resultobj = 0;
48495 wxSizer *arg1 = (wxSizer *) 0 ;
48496 PyObject *arg2 = (PyObject *) 0 ;
48497 bool result;
48498 void *argp1 = 0 ;
48499 int res1 = 0 ;
48500 PyObject * obj0 = 0 ;
48501 PyObject * obj1 = 0 ;
48502 char * kwnames[] = {
48503 (char *) "self",(char *) "item", NULL
48504 };
48505
48506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
48507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48508 if (!SWIG_IsOK(res1)) {
48509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
48510 }
48511 arg1 = reinterpret_cast< wxSizer * >(argp1);
48512 arg2 = obj1;
48513 {
48514 PyThreadState* __tstate = wxPyBeginAllowThreads();
48515 result = (bool)wxSizer_IsShown(arg1,arg2);
48516 wxPyEndAllowThreads(__tstate);
48517 if (PyErr_Occurred()) SWIG_fail;
48518 }
48519 {
48520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48521 }
48522 return resultobj;
48523 fail:
48524 return NULL;
48525 }
48526
48527
48528 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48529 PyObject *resultobj = 0;
48530 wxSizer *arg1 = (wxSizer *) 0 ;
48531 bool arg2 ;
48532 void *argp1 = 0 ;
48533 int res1 = 0 ;
48534 bool val2 ;
48535 int ecode2 = 0 ;
48536 PyObject * obj0 = 0 ;
48537 PyObject * obj1 = 0 ;
48538 char * kwnames[] = {
48539 (char *) "self",(char *) "show", NULL
48540 };
48541
48542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
48543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48544 if (!SWIG_IsOK(res1)) {
48545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
48546 }
48547 arg1 = reinterpret_cast< wxSizer * >(argp1);
48548 ecode2 = SWIG_AsVal_bool(obj1, &val2);
48549 if (!SWIG_IsOK(ecode2)) {
48550 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
48551 }
48552 arg2 = static_cast< bool >(val2);
48553 {
48554 PyThreadState* __tstate = wxPyBeginAllowThreads();
48555 (arg1)->ShowItems(arg2);
48556 wxPyEndAllowThreads(__tstate);
48557 if (PyErr_Occurred()) SWIG_fail;
48558 }
48559 resultobj = SWIG_Py_Void();
48560 return resultobj;
48561 fail:
48562 return NULL;
48563 }
48564
48565
48566 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48567 PyObject *obj;
48568 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48569 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
48570 return SWIG_Py_Void();
48571 }
48572
48573 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48574 PyObject *resultobj = 0;
48575 wxPySizer *result = 0 ;
48576
48577 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
48578 {
48579 PyThreadState* __tstate = wxPyBeginAllowThreads();
48580 result = (wxPySizer *)new wxPySizer();
48581 wxPyEndAllowThreads(__tstate);
48582 if (PyErr_Occurred()) SWIG_fail;
48583 }
48584 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
48585 return resultobj;
48586 fail:
48587 return NULL;
48588 }
48589
48590
48591 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48592 PyObject *resultobj = 0;
48593 wxPySizer *arg1 = (wxPySizer *) 0 ;
48594 PyObject *arg2 = (PyObject *) 0 ;
48595 PyObject *arg3 = (PyObject *) 0 ;
48596 void *argp1 = 0 ;
48597 int res1 = 0 ;
48598 PyObject * obj0 = 0 ;
48599 PyObject * obj1 = 0 ;
48600 PyObject * obj2 = 0 ;
48601 char * kwnames[] = {
48602 (char *) "self",(char *) "self",(char *) "_class", NULL
48603 };
48604
48605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
48607 if (!SWIG_IsOK(res1)) {
48608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
48609 }
48610 arg1 = reinterpret_cast< wxPySizer * >(argp1);
48611 arg2 = obj1;
48612 arg3 = obj2;
48613 {
48614 PyThreadState* __tstate = wxPyBeginAllowThreads();
48615 (arg1)->_setCallbackInfo(arg2,arg3);
48616 wxPyEndAllowThreads(__tstate);
48617 if (PyErr_Occurred()) SWIG_fail;
48618 }
48619 resultobj = SWIG_Py_Void();
48620 return resultobj;
48621 fail:
48622 return NULL;
48623 }
48624
48625
48626 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48627 PyObject *obj;
48628 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48629 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
48630 return SWIG_Py_Void();
48631 }
48632
48633 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48634 return SWIG_Python_InitShadowInstance(args);
48635 }
48636
48637 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48638 PyObject *resultobj = 0;
48639 int arg1 = (int) wxHORIZONTAL ;
48640 wxBoxSizer *result = 0 ;
48641 int val1 ;
48642 int ecode1 = 0 ;
48643 PyObject * obj0 = 0 ;
48644 char * kwnames[] = {
48645 (char *) "orient", NULL
48646 };
48647
48648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
48649 if (obj0) {
48650 ecode1 = SWIG_AsVal_int(obj0, &val1);
48651 if (!SWIG_IsOK(ecode1)) {
48652 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
48653 }
48654 arg1 = static_cast< int >(val1);
48655 }
48656 {
48657 PyThreadState* __tstate = wxPyBeginAllowThreads();
48658 result = (wxBoxSizer *)new wxBoxSizer(arg1);
48659 wxPyEndAllowThreads(__tstate);
48660 if (PyErr_Occurred()) SWIG_fail;
48661 }
48662 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
48663 return resultobj;
48664 fail:
48665 return NULL;
48666 }
48667
48668
48669 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48670 PyObject *resultobj = 0;
48671 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
48672 int result;
48673 void *argp1 = 0 ;
48674 int res1 = 0 ;
48675 PyObject *swig_obj[1] ;
48676
48677 if (!args) SWIG_fail;
48678 swig_obj[0] = args;
48679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
48680 if (!SWIG_IsOK(res1)) {
48681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
48682 }
48683 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
48684 {
48685 PyThreadState* __tstate = wxPyBeginAllowThreads();
48686 result = (int)(arg1)->GetOrientation();
48687 wxPyEndAllowThreads(__tstate);
48688 if (PyErr_Occurred()) SWIG_fail;
48689 }
48690 resultobj = SWIG_From_int(static_cast< int >(result));
48691 return resultobj;
48692 fail:
48693 return NULL;
48694 }
48695
48696
48697 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48698 PyObject *resultobj = 0;
48699 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
48700 int arg2 ;
48701 void *argp1 = 0 ;
48702 int res1 = 0 ;
48703 int val2 ;
48704 int ecode2 = 0 ;
48705 PyObject * obj0 = 0 ;
48706 PyObject * obj1 = 0 ;
48707 char * kwnames[] = {
48708 (char *) "self",(char *) "orient", NULL
48709 };
48710
48711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
48712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
48713 if (!SWIG_IsOK(res1)) {
48714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
48715 }
48716 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
48717 ecode2 = SWIG_AsVal_int(obj1, &val2);
48718 if (!SWIG_IsOK(ecode2)) {
48719 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
48720 }
48721 arg2 = static_cast< int >(val2);
48722 {
48723 PyThreadState* __tstate = wxPyBeginAllowThreads();
48724 (arg1)->SetOrientation(arg2);
48725 wxPyEndAllowThreads(__tstate);
48726 if (PyErr_Occurred()) SWIG_fail;
48727 }
48728 resultobj = SWIG_Py_Void();
48729 return resultobj;
48730 fail:
48731 return NULL;
48732 }
48733
48734
48735 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48736 PyObject *obj;
48737 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48738 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
48739 return SWIG_Py_Void();
48740 }
48741
48742 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48743 return SWIG_Python_InitShadowInstance(args);
48744 }
48745
48746 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48747 PyObject *resultobj = 0;
48748 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
48749 int arg2 = (int) wxHORIZONTAL ;
48750 wxStaticBoxSizer *result = 0 ;
48751 void *argp1 = 0 ;
48752 int res1 = 0 ;
48753 int val2 ;
48754 int ecode2 = 0 ;
48755 PyObject * obj0 = 0 ;
48756 PyObject * obj1 = 0 ;
48757 char * kwnames[] = {
48758 (char *) "box",(char *) "orient", NULL
48759 };
48760
48761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
48762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
48763 if (!SWIG_IsOK(res1)) {
48764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
48765 }
48766 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
48767 if (obj1) {
48768 ecode2 = SWIG_AsVal_int(obj1, &val2);
48769 if (!SWIG_IsOK(ecode2)) {
48770 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
48771 }
48772 arg2 = static_cast< int >(val2);
48773 }
48774 {
48775 PyThreadState* __tstate = wxPyBeginAllowThreads();
48776 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
48777 wxPyEndAllowThreads(__tstate);
48778 if (PyErr_Occurred()) SWIG_fail;
48779 }
48780 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
48781 return resultobj;
48782 fail:
48783 return NULL;
48784 }
48785
48786
48787 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48788 PyObject *resultobj = 0;
48789 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
48790 wxStaticBox *result = 0 ;
48791 void *argp1 = 0 ;
48792 int res1 = 0 ;
48793 PyObject *swig_obj[1] ;
48794
48795 if (!args) SWIG_fail;
48796 swig_obj[0] = args;
48797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
48798 if (!SWIG_IsOK(res1)) {
48799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
48800 }
48801 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
48802 {
48803 PyThreadState* __tstate = wxPyBeginAllowThreads();
48804 result = (wxStaticBox *)(arg1)->GetStaticBox();
48805 wxPyEndAllowThreads(__tstate);
48806 if (PyErr_Occurred()) SWIG_fail;
48807 }
48808 {
48809 resultobj = wxPyMake_wxObject(result, (bool)0);
48810 }
48811 return resultobj;
48812 fail:
48813 return NULL;
48814 }
48815
48816
48817 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48818 PyObject *obj;
48819 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48820 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
48821 return SWIG_Py_Void();
48822 }
48823
48824 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48825 return SWIG_Python_InitShadowInstance(args);
48826 }
48827
48828 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48829 PyObject *resultobj = 0;
48830 int arg1 = (int) 1 ;
48831 int arg2 = (int) 0 ;
48832 int arg3 = (int) 0 ;
48833 int arg4 = (int) 0 ;
48834 wxGridSizer *result = 0 ;
48835 int val1 ;
48836 int ecode1 = 0 ;
48837 int val2 ;
48838 int ecode2 = 0 ;
48839 int val3 ;
48840 int ecode3 = 0 ;
48841 int val4 ;
48842 int ecode4 = 0 ;
48843 PyObject * obj0 = 0 ;
48844 PyObject * obj1 = 0 ;
48845 PyObject * obj2 = 0 ;
48846 PyObject * obj3 = 0 ;
48847 char * kwnames[] = {
48848 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
48849 };
48850
48851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48852 if (obj0) {
48853 ecode1 = SWIG_AsVal_int(obj0, &val1);
48854 if (!SWIG_IsOK(ecode1)) {
48855 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
48856 }
48857 arg1 = static_cast< int >(val1);
48858 }
48859 if (obj1) {
48860 ecode2 = SWIG_AsVal_int(obj1, &val2);
48861 if (!SWIG_IsOK(ecode2)) {
48862 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
48863 }
48864 arg2 = static_cast< int >(val2);
48865 }
48866 if (obj2) {
48867 ecode3 = SWIG_AsVal_int(obj2, &val3);
48868 if (!SWIG_IsOK(ecode3)) {
48869 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
48870 }
48871 arg3 = static_cast< int >(val3);
48872 }
48873 if (obj3) {
48874 ecode4 = SWIG_AsVal_int(obj3, &val4);
48875 if (!SWIG_IsOK(ecode4)) {
48876 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
48877 }
48878 arg4 = static_cast< int >(val4);
48879 }
48880 {
48881 PyThreadState* __tstate = wxPyBeginAllowThreads();
48882 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
48883 wxPyEndAllowThreads(__tstate);
48884 if (PyErr_Occurred()) SWIG_fail;
48885 }
48886 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
48887 return resultobj;
48888 fail:
48889 return NULL;
48890 }
48891
48892
48893 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48894 PyObject *resultobj = 0;
48895 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48896 int arg2 ;
48897 void *argp1 = 0 ;
48898 int res1 = 0 ;
48899 int val2 ;
48900 int ecode2 = 0 ;
48901 PyObject * obj0 = 0 ;
48902 PyObject * obj1 = 0 ;
48903 char * kwnames[] = {
48904 (char *) "self",(char *) "cols", NULL
48905 };
48906
48907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
48908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48909 if (!SWIG_IsOK(res1)) {
48910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48911 }
48912 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48913 ecode2 = SWIG_AsVal_int(obj1, &val2);
48914 if (!SWIG_IsOK(ecode2)) {
48915 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
48916 }
48917 arg2 = static_cast< int >(val2);
48918 {
48919 PyThreadState* __tstate = wxPyBeginAllowThreads();
48920 (arg1)->SetCols(arg2);
48921 wxPyEndAllowThreads(__tstate);
48922 if (PyErr_Occurred()) SWIG_fail;
48923 }
48924 resultobj = SWIG_Py_Void();
48925 return resultobj;
48926 fail:
48927 return NULL;
48928 }
48929
48930
48931 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48932 PyObject *resultobj = 0;
48933 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48934 int arg2 ;
48935 void *argp1 = 0 ;
48936 int res1 = 0 ;
48937 int val2 ;
48938 int ecode2 = 0 ;
48939 PyObject * obj0 = 0 ;
48940 PyObject * obj1 = 0 ;
48941 char * kwnames[] = {
48942 (char *) "self",(char *) "rows", NULL
48943 };
48944
48945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
48946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48947 if (!SWIG_IsOK(res1)) {
48948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48949 }
48950 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48951 ecode2 = SWIG_AsVal_int(obj1, &val2);
48952 if (!SWIG_IsOK(ecode2)) {
48953 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
48954 }
48955 arg2 = static_cast< int >(val2);
48956 {
48957 PyThreadState* __tstate = wxPyBeginAllowThreads();
48958 (arg1)->SetRows(arg2);
48959 wxPyEndAllowThreads(__tstate);
48960 if (PyErr_Occurred()) SWIG_fail;
48961 }
48962 resultobj = SWIG_Py_Void();
48963 return resultobj;
48964 fail:
48965 return NULL;
48966 }
48967
48968
48969 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48970 PyObject *resultobj = 0;
48971 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48972 int arg2 ;
48973 void *argp1 = 0 ;
48974 int res1 = 0 ;
48975 int val2 ;
48976 int ecode2 = 0 ;
48977 PyObject * obj0 = 0 ;
48978 PyObject * obj1 = 0 ;
48979 char * kwnames[] = {
48980 (char *) "self",(char *) "gap", NULL
48981 };
48982
48983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
48984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48985 if (!SWIG_IsOK(res1)) {
48986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48987 }
48988 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48989 ecode2 = SWIG_AsVal_int(obj1, &val2);
48990 if (!SWIG_IsOK(ecode2)) {
48991 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
48992 }
48993 arg2 = static_cast< int >(val2);
48994 {
48995 PyThreadState* __tstate = wxPyBeginAllowThreads();
48996 (arg1)->SetVGap(arg2);
48997 wxPyEndAllowThreads(__tstate);
48998 if (PyErr_Occurred()) SWIG_fail;
48999 }
49000 resultobj = SWIG_Py_Void();
49001 return resultobj;
49002 fail:
49003 return NULL;
49004 }
49005
49006
49007 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49008 PyObject *resultobj = 0;
49009 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49010 int arg2 ;
49011 void *argp1 = 0 ;
49012 int res1 = 0 ;
49013 int val2 ;
49014 int ecode2 = 0 ;
49015 PyObject * obj0 = 0 ;
49016 PyObject * obj1 = 0 ;
49017 char * kwnames[] = {
49018 (char *) "self",(char *) "gap", NULL
49019 };
49020
49021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
49022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49023 if (!SWIG_IsOK(res1)) {
49024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49025 }
49026 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49027 ecode2 = SWIG_AsVal_int(obj1, &val2);
49028 if (!SWIG_IsOK(ecode2)) {
49029 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
49030 }
49031 arg2 = static_cast< int >(val2);
49032 {
49033 PyThreadState* __tstate = wxPyBeginAllowThreads();
49034 (arg1)->SetHGap(arg2);
49035 wxPyEndAllowThreads(__tstate);
49036 if (PyErr_Occurred()) SWIG_fail;
49037 }
49038 resultobj = SWIG_Py_Void();
49039 return resultobj;
49040 fail:
49041 return NULL;
49042 }
49043
49044
49045 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49046 PyObject *resultobj = 0;
49047 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49048 int result;
49049 void *argp1 = 0 ;
49050 int res1 = 0 ;
49051 PyObject *swig_obj[1] ;
49052
49053 if (!args) SWIG_fail;
49054 swig_obj[0] = args;
49055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49056 if (!SWIG_IsOK(res1)) {
49057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49058 }
49059 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49060 {
49061 PyThreadState* __tstate = wxPyBeginAllowThreads();
49062 result = (int)(arg1)->GetCols();
49063 wxPyEndAllowThreads(__tstate);
49064 if (PyErr_Occurred()) SWIG_fail;
49065 }
49066 resultobj = SWIG_From_int(static_cast< int >(result));
49067 return resultobj;
49068 fail:
49069 return NULL;
49070 }
49071
49072
49073 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49074 PyObject *resultobj = 0;
49075 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49076 int result;
49077 void *argp1 = 0 ;
49078 int res1 = 0 ;
49079 PyObject *swig_obj[1] ;
49080
49081 if (!args) SWIG_fail;
49082 swig_obj[0] = args;
49083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49084 if (!SWIG_IsOK(res1)) {
49085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49086 }
49087 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49088 {
49089 PyThreadState* __tstate = wxPyBeginAllowThreads();
49090 result = (int)(arg1)->GetRows();
49091 wxPyEndAllowThreads(__tstate);
49092 if (PyErr_Occurred()) SWIG_fail;
49093 }
49094 resultobj = SWIG_From_int(static_cast< int >(result));
49095 return resultobj;
49096 fail:
49097 return NULL;
49098 }
49099
49100
49101 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49102 PyObject *resultobj = 0;
49103 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49104 int result;
49105 void *argp1 = 0 ;
49106 int res1 = 0 ;
49107 PyObject *swig_obj[1] ;
49108
49109 if (!args) SWIG_fail;
49110 swig_obj[0] = args;
49111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49112 if (!SWIG_IsOK(res1)) {
49113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49114 }
49115 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49116 {
49117 PyThreadState* __tstate = wxPyBeginAllowThreads();
49118 result = (int)(arg1)->GetVGap();
49119 wxPyEndAllowThreads(__tstate);
49120 if (PyErr_Occurred()) SWIG_fail;
49121 }
49122 resultobj = SWIG_From_int(static_cast< int >(result));
49123 return resultobj;
49124 fail:
49125 return NULL;
49126 }
49127
49128
49129 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49130 PyObject *resultobj = 0;
49131 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49132 int result;
49133 void *argp1 = 0 ;
49134 int res1 = 0 ;
49135 PyObject *swig_obj[1] ;
49136
49137 if (!args) SWIG_fail;
49138 swig_obj[0] = args;
49139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49140 if (!SWIG_IsOK(res1)) {
49141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49142 }
49143 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49144 {
49145 PyThreadState* __tstate = wxPyBeginAllowThreads();
49146 result = (int)(arg1)->GetHGap();
49147 wxPyEndAllowThreads(__tstate);
49148 if (PyErr_Occurred()) SWIG_fail;
49149 }
49150 resultobj = SWIG_From_int(static_cast< int >(result));
49151 return resultobj;
49152 fail:
49153 return NULL;
49154 }
49155
49156
49157 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49158 PyObject *obj;
49159 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49160 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
49161 return SWIG_Py_Void();
49162 }
49163
49164 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49165 return SWIG_Python_InitShadowInstance(args);
49166 }
49167
49168 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49169 PyObject *resultobj = 0;
49170 int arg1 = (int) 1 ;
49171 int arg2 = (int) 0 ;
49172 int arg3 = (int) 0 ;
49173 int arg4 = (int) 0 ;
49174 wxFlexGridSizer *result = 0 ;
49175 int val1 ;
49176 int ecode1 = 0 ;
49177 int val2 ;
49178 int ecode2 = 0 ;
49179 int val3 ;
49180 int ecode3 = 0 ;
49181 int val4 ;
49182 int ecode4 = 0 ;
49183 PyObject * obj0 = 0 ;
49184 PyObject * obj1 = 0 ;
49185 PyObject * obj2 = 0 ;
49186 PyObject * obj3 = 0 ;
49187 char * kwnames[] = {
49188 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
49189 };
49190
49191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
49192 if (obj0) {
49193 ecode1 = SWIG_AsVal_int(obj0, &val1);
49194 if (!SWIG_IsOK(ecode1)) {
49195 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
49196 }
49197 arg1 = static_cast< int >(val1);
49198 }
49199 if (obj1) {
49200 ecode2 = SWIG_AsVal_int(obj1, &val2);
49201 if (!SWIG_IsOK(ecode2)) {
49202 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
49203 }
49204 arg2 = static_cast< int >(val2);
49205 }
49206 if (obj2) {
49207 ecode3 = SWIG_AsVal_int(obj2, &val3);
49208 if (!SWIG_IsOK(ecode3)) {
49209 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
49210 }
49211 arg3 = static_cast< int >(val3);
49212 }
49213 if (obj3) {
49214 ecode4 = SWIG_AsVal_int(obj3, &val4);
49215 if (!SWIG_IsOK(ecode4)) {
49216 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
49217 }
49218 arg4 = static_cast< int >(val4);
49219 }
49220 {
49221 PyThreadState* __tstate = wxPyBeginAllowThreads();
49222 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
49223 wxPyEndAllowThreads(__tstate);
49224 if (PyErr_Occurred()) SWIG_fail;
49225 }
49226 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
49227 return resultobj;
49228 fail:
49229 return NULL;
49230 }
49231
49232
49233 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49234 PyObject *resultobj = 0;
49235 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49236 size_t arg2 ;
49237 int arg3 = (int) 0 ;
49238 void *argp1 = 0 ;
49239 int res1 = 0 ;
49240 size_t val2 ;
49241 int ecode2 = 0 ;
49242 int val3 ;
49243 int ecode3 = 0 ;
49244 PyObject * obj0 = 0 ;
49245 PyObject * obj1 = 0 ;
49246 PyObject * obj2 = 0 ;
49247 char * kwnames[] = {
49248 (char *) "self",(char *) "idx",(char *) "proportion", NULL
49249 };
49250
49251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49253 if (!SWIG_IsOK(res1)) {
49254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49255 }
49256 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49257 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49258 if (!SWIG_IsOK(ecode2)) {
49259 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
49260 }
49261 arg2 = static_cast< size_t >(val2);
49262 if (obj2) {
49263 ecode3 = SWIG_AsVal_int(obj2, &val3);
49264 if (!SWIG_IsOK(ecode3)) {
49265 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
49266 }
49267 arg3 = static_cast< int >(val3);
49268 }
49269 {
49270 PyThreadState* __tstate = wxPyBeginAllowThreads();
49271 (arg1)->AddGrowableRow(arg2,arg3);
49272 wxPyEndAllowThreads(__tstate);
49273 if (PyErr_Occurred()) SWIG_fail;
49274 }
49275 resultobj = SWIG_Py_Void();
49276 return resultobj;
49277 fail:
49278 return NULL;
49279 }
49280
49281
49282 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49283 PyObject *resultobj = 0;
49284 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49285 size_t arg2 ;
49286 void *argp1 = 0 ;
49287 int res1 = 0 ;
49288 size_t val2 ;
49289 int ecode2 = 0 ;
49290 PyObject * obj0 = 0 ;
49291 PyObject * obj1 = 0 ;
49292 char * kwnames[] = {
49293 (char *) "self",(char *) "idx", NULL
49294 };
49295
49296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
49297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49298 if (!SWIG_IsOK(res1)) {
49299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49300 }
49301 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49302 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49303 if (!SWIG_IsOK(ecode2)) {
49304 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
49305 }
49306 arg2 = static_cast< size_t >(val2);
49307 {
49308 PyThreadState* __tstate = wxPyBeginAllowThreads();
49309 (arg1)->RemoveGrowableRow(arg2);
49310 wxPyEndAllowThreads(__tstate);
49311 if (PyErr_Occurred()) SWIG_fail;
49312 }
49313 resultobj = SWIG_Py_Void();
49314 return resultobj;
49315 fail:
49316 return NULL;
49317 }
49318
49319
49320 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49321 PyObject *resultobj = 0;
49322 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49323 size_t arg2 ;
49324 int arg3 = (int) 0 ;
49325 void *argp1 = 0 ;
49326 int res1 = 0 ;
49327 size_t val2 ;
49328 int ecode2 = 0 ;
49329 int val3 ;
49330 int ecode3 = 0 ;
49331 PyObject * obj0 = 0 ;
49332 PyObject * obj1 = 0 ;
49333 PyObject * obj2 = 0 ;
49334 char * kwnames[] = {
49335 (char *) "self",(char *) "idx",(char *) "proportion", NULL
49336 };
49337
49338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49340 if (!SWIG_IsOK(res1)) {
49341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49342 }
49343 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49344 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49345 if (!SWIG_IsOK(ecode2)) {
49346 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
49347 }
49348 arg2 = static_cast< size_t >(val2);
49349 if (obj2) {
49350 ecode3 = SWIG_AsVal_int(obj2, &val3);
49351 if (!SWIG_IsOK(ecode3)) {
49352 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
49353 }
49354 arg3 = static_cast< int >(val3);
49355 }
49356 {
49357 PyThreadState* __tstate = wxPyBeginAllowThreads();
49358 (arg1)->AddGrowableCol(arg2,arg3);
49359 wxPyEndAllowThreads(__tstate);
49360 if (PyErr_Occurred()) SWIG_fail;
49361 }
49362 resultobj = SWIG_Py_Void();
49363 return resultobj;
49364 fail:
49365 return NULL;
49366 }
49367
49368
49369 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49370 PyObject *resultobj = 0;
49371 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49372 size_t arg2 ;
49373 void *argp1 = 0 ;
49374 int res1 = 0 ;
49375 size_t val2 ;
49376 int ecode2 = 0 ;
49377 PyObject * obj0 = 0 ;
49378 PyObject * obj1 = 0 ;
49379 char * kwnames[] = {
49380 (char *) "self",(char *) "idx", NULL
49381 };
49382
49383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
49384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49385 if (!SWIG_IsOK(res1)) {
49386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49387 }
49388 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49389 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49390 if (!SWIG_IsOK(ecode2)) {
49391 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
49392 }
49393 arg2 = static_cast< size_t >(val2);
49394 {
49395 PyThreadState* __tstate = wxPyBeginAllowThreads();
49396 (arg1)->RemoveGrowableCol(arg2);
49397 wxPyEndAllowThreads(__tstate);
49398 if (PyErr_Occurred()) SWIG_fail;
49399 }
49400 resultobj = SWIG_Py_Void();
49401 return resultobj;
49402 fail:
49403 return NULL;
49404 }
49405
49406
49407 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49408 PyObject *resultobj = 0;
49409 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49410 int arg2 ;
49411 void *argp1 = 0 ;
49412 int res1 = 0 ;
49413 int val2 ;
49414 int ecode2 = 0 ;
49415 PyObject * obj0 = 0 ;
49416 PyObject * obj1 = 0 ;
49417 char * kwnames[] = {
49418 (char *) "self",(char *) "direction", NULL
49419 };
49420
49421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
49422 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49423 if (!SWIG_IsOK(res1)) {
49424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49425 }
49426 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49427 ecode2 = SWIG_AsVal_int(obj1, &val2);
49428 if (!SWIG_IsOK(ecode2)) {
49429 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
49430 }
49431 arg2 = static_cast< int >(val2);
49432 {
49433 PyThreadState* __tstate = wxPyBeginAllowThreads();
49434 (arg1)->SetFlexibleDirection(arg2);
49435 wxPyEndAllowThreads(__tstate);
49436 if (PyErr_Occurred()) SWIG_fail;
49437 }
49438 resultobj = SWIG_Py_Void();
49439 return resultobj;
49440 fail:
49441 return NULL;
49442 }
49443
49444
49445 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49446 PyObject *resultobj = 0;
49447 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49448 int result;
49449 void *argp1 = 0 ;
49450 int res1 = 0 ;
49451 PyObject *swig_obj[1] ;
49452
49453 if (!args) SWIG_fail;
49454 swig_obj[0] = args;
49455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49456 if (!SWIG_IsOK(res1)) {
49457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49458 }
49459 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49460 {
49461 PyThreadState* __tstate = wxPyBeginAllowThreads();
49462 result = (int)(arg1)->GetFlexibleDirection();
49463 wxPyEndAllowThreads(__tstate);
49464 if (PyErr_Occurred()) SWIG_fail;
49465 }
49466 resultobj = SWIG_From_int(static_cast< int >(result));
49467 return resultobj;
49468 fail:
49469 return NULL;
49470 }
49471
49472
49473 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49474 PyObject *resultobj = 0;
49475 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49476 wxFlexSizerGrowMode arg2 ;
49477 void *argp1 = 0 ;
49478 int res1 = 0 ;
49479 int val2 ;
49480 int ecode2 = 0 ;
49481 PyObject * obj0 = 0 ;
49482 PyObject * obj1 = 0 ;
49483 char * kwnames[] = {
49484 (char *) "self",(char *) "mode", NULL
49485 };
49486
49487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
49488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49489 if (!SWIG_IsOK(res1)) {
49490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49491 }
49492 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49493 ecode2 = SWIG_AsVal_int(obj1, &val2);
49494 if (!SWIG_IsOK(ecode2)) {
49495 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
49496 }
49497 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
49498 {
49499 PyThreadState* __tstate = wxPyBeginAllowThreads();
49500 (arg1)->SetNonFlexibleGrowMode(arg2);
49501 wxPyEndAllowThreads(__tstate);
49502 if (PyErr_Occurred()) SWIG_fail;
49503 }
49504 resultobj = SWIG_Py_Void();
49505 return resultobj;
49506 fail:
49507 return NULL;
49508 }
49509
49510
49511 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49512 PyObject *resultobj = 0;
49513 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49514 wxFlexSizerGrowMode result;
49515 void *argp1 = 0 ;
49516 int res1 = 0 ;
49517 PyObject *swig_obj[1] ;
49518
49519 if (!args) SWIG_fail;
49520 swig_obj[0] = args;
49521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49522 if (!SWIG_IsOK(res1)) {
49523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49524 }
49525 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49526 {
49527 PyThreadState* __tstate = wxPyBeginAllowThreads();
49528 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
49529 wxPyEndAllowThreads(__tstate);
49530 if (PyErr_Occurred()) SWIG_fail;
49531 }
49532 resultobj = SWIG_From_int(static_cast< int >(result));
49533 return resultobj;
49534 fail:
49535 return NULL;
49536 }
49537
49538
49539 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49540 PyObject *resultobj = 0;
49541 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49542 wxArrayInt *result = 0 ;
49543 void *argp1 = 0 ;
49544 int res1 = 0 ;
49545 PyObject *swig_obj[1] ;
49546
49547 if (!args) SWIG_fail;
49548 swig_obj[0] = args;
49549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49550 if (!SWIG_IsOK(res1)) {
49551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
49552 }
49553 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49554 {
49555 PyThreadState* __tstate = wxPyBeginAllowThreads();
49556 {
49557 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
49558 result = (wxArrayInt *) &_result_ref;
49559 }
49560 wxPyEndAllowThreads(__tstate);
49561 if (PyErr_Occurred()) SWIG_fail;
49562 }
49563 {
49564 resultobj = PyList_New(0);
49565 size_t idx;
49566 for (idx = 0; idx < result->GetCount(); idx += 1) {
49567 PyObject* val = PyInt_FromLong( result->Item(idx) );
49568 PyList_Append(resultobj, val);
49569 Py_DECREF(val);
49570 }
49571 }
49572 return resultobj;
49573 fail:
49574 return NULL;
49575 }
49576
49577
49578 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49579 PyObject *resultobj = 0;
49580 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49581 wxArrayInt *result = 0 ;
49582 void *argp1 = 0 ;
49583 int res1 = 0 ;
49584 PyObject *swig_obj[1] ;
49585
49586 if (!args) SWIG_fail;
49587 swig_obj[0] = args;
49588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49589 if (!SWIG_IsOK(res1)) {
49590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
49591 }
49592 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49593 {
49594 PyThreadState* __tstate = wxPyBeginAllowThreads();
49595 {
49596 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
49597 result = (wxArrayInt *) &_result_ref;
49598 }
49599 wxPyEndAllowThreads(__tstate);
49600 if (PyErr_Occurred()) SWIG_fail;
49601 }
49602 {
49603 resultobj = PyList_New(0);
49604 size_t idx;
49605 for (idx = 0; idx < result->GetCount(); idx += 1) {
49606 PyObject* val = PyInt_FromLong( result->Item(idx) );
49607 PyList_Append(resultobj, val);
49608 Py_DECREF(val);
49609 }
49610 }
49611 return resultobj;
49612 fail:
49613 return NULL;
49614 }
49615
49616
49617 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49618 PyObject *obj;
49619 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49620 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
49621 return SWIG_Py_Void();
49622 }
49623
49624 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49625 return SWIG_Python_InitShadowInstance(args);
49626 }
49627
49628 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49629 PyObject *resultobj = 0;
49630 wxStdDialogButtonSizer *result = 0 ;
49631
49632 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
49633 {
49634 PyThreadState* __tstate = wxPyBeginAllowThreads();
49635 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
49636 wxPyEndAllowThreads(__tstate);
49637 if (PyErr_Occurred()) SWIG_fail;
49638 }
49639 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
49640 return resultobj;
49641 fail:
49642 return NULL;
49643 }
49644
49645
49646 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49647 PyObject *resultobj = 0;
49648 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49649 wxButton *arg2 = (wxButton *) 0 ;
49650 void *argp1 = 0 ;
49651 int res1 = 0 ;
49652 void *argp2 = 0 ;
49653 int res2 = 0 ;
49654 PyObject * obj0 = 0 ;
49655 PyObject * obj1 = 0 ;
49656 char * kwnames[] = {
49657 (char *) "self",(char *) "button", NULL
49658 };
49659
49660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
49661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49662 if (!SWIG_IsOK(res1)) {
49663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49664 }
49665 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49666 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
49667 if (!SWIG_IsOK(res2)) {
49668 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
49669 }
49670 arg2 = reinterpret_cast< wxButton * >(argp2);
49671 {
49672 PyThreadState* __tstate = wxPyBeginAllowThreads();
49673 (arg1)->AddButton(arg2);
49674 wxPyEndAllowThreads(__tstate);
49675 if (PyErr_Occurred()) SWIG_fail;
49676 }
49677 resultobj = SWIG_Py_Void();
49678 return resultobj;
49679 fail:
49680 return NULL;
49681 }
49682
49683
49684 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49685 PyObject *resultobj = 0;
49686 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49687 void *argp1 = 0 ;
49688 int res1 = 0 ;
49689 PyObject *swig_obj[1] ;
49690
49691 if (!args) SWIG_fail;
49692 swig_obj[0] = args;
49693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49694 if (!SWIG_IsOK(res1)) {
49695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49696 }
49697 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49698 {
49699 PyThreadState* __tstate = wxPyBeginAllowThreads();
49700 (arg1)->Realize();
49701 wxPyEndAllowThreads(__tstate);
49702 if (PyErr_Occurred()) SWIG_fail;
49703 }
49704 resultobj = SWIG_Py_Void();
49705 return resultobj;
49706 fail:
49707 return NULL;
49708 }
49709
49710
49711 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49712 PyObject *resultobj = 0;
49713 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49714 wxButton *arg2 = (wxButton *) 0 ;
49715 void *argp1 = 0 ;
49716 int res1 = 0 ;
49717 void *argp2 = 0 ;
49718 int res2 = 0 ;
49719 PyObject * obj0 = 0 ;
49720 PyObject * obj1 = 0 ;
49721 char * kwnames[] = {
49722 (char *) "self",(char *) "button", NULL
49723 };
49724
49725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
49726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49727 if (!SWIG_IsOK(res1)) {
49728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49729 }
49730 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49731 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
49732 if (!SWIG_IsOK(res2)) {
49733 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
49734 }
49735 arg2 = reinterpret_cast< wxButton * >(argp2);
49736 {
49737 PyThreadState* __tstate = wxPyBeginAllowThreads();
49738 (arg1)->SetAffirmativeButton(arg2);
49739 wxPyEndAllowThreads(__tstate);
49740 if (PyErr_Occurred()) SWIG_fail;
49741 }
49742 resultobj = SWIG_Py_Void();
49743 return resultobj;
49744 fail:
49745 return NULL;
49746 }
49747
49748
49749 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49750 PyObject *resultobj = 0;
49751 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49752 wxButton *arg2 = (wxButton *) 0 ;
49753 void *argp1 = 0 ;
49754 int res1 = 0 ;
49755 void *argp2 = 0 ;
49756 int res2 = 0 ;
49757 PyObject * obj0 = 0 ;
49758 PyObject * obj1 = 0 ;
49759 char * kwnames[] = {
49760 (char *) "self",(char *) "button", NULL
49761 };
49762
49763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
49764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49765 if (!SWIG_IsOK(res1)) {
49766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49767 }
49768 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49769 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
49770 if (!SWIG_IsOK(res2)) {
49771 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
49772 }
49773 arg2 = reinterpret_cast< wxButton * >(argp2);
49774 {
49775 PyThreadState* __tstate = wxPyBeginAllowThreads();
49776 (arg1)->SetNegativeButton(arg2);
49777 wxPyEndAllowThreads(__tstate);
49778 if (PyErr_Occurred()) SWIG_fail;
49779 }
49780 resultobj = SWIG_Py_Void();
49781 return resultobj;
49782 fail:
49783 return NULL;
49784 }
49785
49786
49787 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49788 PyObject *resultobj = 0;
49789 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49790 wxButton *arg2 = (wxButton *) 0 ;
49791 void *argp1 = 0 ;
49792 int res1 = 0 ;
49793 void *argp2 = 0 ;
49794 int res2 = 0 ;
49795 PyObject * obj0 = 0 ;
49796 PyObject * obj1 = 0 ;
49797 char * kwnames[] = {
49798 (char *) "self",(char *) "button", NULL
49799 };
49800
49801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
49802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49803 if (!SWIG_IsOK(res1)) {
49804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49805 }
49806 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49807 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
49808 if (!SWIG_IsOK(res2)) {
49809 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
49810 }
49811 arg2 = reinterpret_cast< wxButton * >(argp2);
49812 {
49813 PyThreadState* __tstate = wxPyBeginAllowThreads();
49814 (arg1)->SetCancelButton(arg2);
49815 wxPyEndAllowThreads(__tstate);
49816 if (PyErr_Occurred()) SWIG_fail;
49817 }
49818 resultobj = SWIG_Py_Void();
49819 return resultobj;
49820 fail:
49821 return NULL;
49822 }
49823
49824
49825 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49826 PyObject *resultobj = 0;
49827 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49828 wxButton *result = 0 ;
49829 void *argp1 = 0 ;
49830 int res1 = 0 ;
49831 PyObject *swig_obj[1] ;
49832
49833 if (!args) SWIG_fail;
49834 swig_obj[0] = args;
49835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49836 if (!SWIG_IsOK(res1)) {
49837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49838 }
49839 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49840 {
49841 PyThreadState* __tstate = wxPyBeginAllowThreads();
49842 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
49843 wxPyEndAllowThreads(__tstate);
49844 if (PyErr_Occurred()) SWIG_fail;
49845 }
49846 {
49847 resultobj = wxPyMake_wxObject(result, (bool)0);
49848 }
49849 return resultobj;
49850 fail:
49851 return NULL;
49852 }
49853
49854
49855 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49856 PyObject *resultobj = 0;
49857 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49858 wxButton *result = 0 ;
49859 void *argp1 = 0 ;
49860 int res1 = 0 ;
49861 PyObject *swig_obj[1] ;
49862
49863 if (!args) SWIG_fail;
49864 swig_obj[0] = args;
49865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49866 if (!SWIG_IsOK(res1)) {
49867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49868 }
49869 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49870 {
49871 PyThreadState* __tstate = wxPyBeginAllowThreads();
49872 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
49873 wxPyEndAllowThreads(__tstate);
49874 if (PyErr_Occurred()) SWIG_fail;
49875 }
49876 {
49877 resultobj = wxPyMake_wxObject(result, (bool)0);
49878 }
49879 return resultobj;
49880 fail:
49881 return NULL;
49882 }
49883
49884
49885 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49886 PyObject *resultobj = 0;
49887 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49888 wxButton *result = 0 ;
49889 void *argp1 = 0 ;
49890 int res1 = 0 ;
49891 PyObject *swig_obj[1] ;
49892
49893 if (!args) SWIG_fail;
49894 swig_obj[0] = args;
49895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49896 if (!SWIG_IsOK(res1)) {
49897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49898 }
49899 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49900 {
49901 PyThreadState* __tstate = wxPyBeginAllowThreads();
49902 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
49903 wxPyEndAllowThreads(__tstate);
49904 if (PyErr_Occurred()) SWIG_fail;
49905 }
49906 {
49907 resultobj = wxPyMake_wxObject(result, (bool)0);
49908 }
49909 return resultobj;
49910 fail:
49911 return NULL;
49912 }
49913
49914
49915 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49916 PyObject *resultobj = 0;
49917 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49918 wxButton *result = 0 ;
49919 void *argp1 = 0 ;
49920 int res1 = 0 ;
49921 PyObject *swig_obj[1] ;
49922
49923 if (!args) SWIG_fail;
49924 swig_obj[0] = args;
49925 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49926 if (!SWIG_IsOK(res1)) {
49927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49928 }
49929 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49930 {
49931 PyThreadState* __tstate = wxPyBeginAllowThreads();
49932 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
49933 wxPyEndAllowThreads(__tstate);
49934 if (PyErr_Occurred()) SWIG_fail;
49935 }
49936 {
49937 resultobj = wxPyMake_wxObject(result, (bool)0);
49938 }
49939 return resultobj;
49940 fail:
49941 return NULL;
49942 }
49943
49944
49945 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49946 PyObject *resultobj = 0;
49947 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49948 wxButton *result = 0 ;
49949 void *argp1 = 0 ;
49950 int res1 = 0 ;
49951 PyObject *swig_obj[1] ;
49952
49953 if (!args) SWIG_fail;
49954 swig_obj[0] = args;
49955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49956 if (!SWIG_IsOK(res1)) {
49957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49958 }
49959 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49960 {
49961 PyThreadState* __tstate = wxPyBeginAllowThreads();
49962 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
49963 wxPyEndAllowThreads(__tstate);
49964 if (PyErr_Occurred()) SWIG_fail;
49965 }
49966 {
49967 resultobj = wxPyMake_wxObject(result, (bool)0);
49968 }
49969 return resultobj;
49970 fail:
49971 return NULL;
49972 }
49973
49974
49975 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49976 PyObject *obj;
49977 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49978 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
49979 return SWIG_Py_Void();
49980 }
49981
49982 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49983 return SWIG_Python_InitShadowInstance(args);
49984 }
49985
49986 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49987 PyObject *resultobj = 0;
49988 int arg1 = (int) 0 ;
49989 int arg2 = (int) 0 ;
49990 wxGBPosition *result = 0 ;
49991 int val1 ;
49992 int ecode1 = 0 ;
49993 int val2 ;
49994 int ecode2 = 0 ;
49995 PyObject * obj0 = 0 ;
49996 PyObject * obj1 = 0 ;
49997 char * kwnames[] = {
49998 (char *) "row",(char *) "col", NULL
49999 };
50000
50001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
50002 if (obj0) {
50003 ecode1 = SWIG_AsVal_int(obj0, &val1);
50004 if (!SWIG_IsOK(ecode1)) {
50005 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
50006 }
50007 arg1 = static_cast< int >(val1);
50008 }
50009 if (obj1) {
50010 ecode2 = SWIG_AsVal_int(obj1, &val2);
50011 if (!SWIG_IsOK(ecode2)) {
50012 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
50013 }
50014 arg2 = static_cast< int >(val2);
50015 }
50016 {
50017 PyThreadState* __tstate = wxPyBeginAllowThreads();
50018 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
50019 wxPyEndAllowThreads(__tstate);
50020 if (PyErr_Occurred()) SWIG_fail;
50021 }
50022 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
50023 return resultobj;
50024 fail:
50025 return NULL;
50026 }
50027
50028
50029 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50030 PyObject *resultobj = 0;
50031 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50032 void *argp1 = 0 ;
50033 int res1 = 0 ;
50034 PyObject *swig_obj[1] ;
50035
50036 if (!args) SWIG_fail;
50037 swig_obj[0] = args;
50038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
50039 if (!SWIG_IsOK(res1)) {
50040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50041 }
50042 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50043 {
50044 PyThreadState* __tstate = wxPyBeginAllowThreads();
50045 delete arg1;
50046
50047 wxPyEndAllowThreads(__tstate);
50048 if (PyErr_Occurred()) SWIG_fail;
50049 }
50050 resultobj = SWIG_Py_Void();
50051 return resultobj;
50052 fail:
50053 return NULL;
50054 }
50055
50056
50057 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50058 PyObject *resultobj = 0;
50059 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50060 int result;
50061 void *argp1 = 0 ;
50062 int res1 = 0 ;
50063 PyObject *swig_obj[1] ;
50064
50065 if (!args) SWIG_fail;
50066 swig_obj[0] = args;
50067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50068 if (!SWIG_IsOK(res1)) {
50069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
50070 }
50071 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50072 {
50073 PyThreadState* __tstate = wxPyBeginAllowThreads();
50074 result = (int)((wxGBPosition const *)arg1)->GetRow();
50075 wxPyEndAllowThreads(__tstate);
50076 if (PyErr_Occurred()) SWIG_fail;
50077 }
50078 resultobj = SWIG_From_int(static_cast< int >(result));
50079 return resultobj;
50080 fail:
50081 return NULL;
50082 }
50083
50084
50085 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50086 PyObject *resultobj = 0;
50087 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50088 int result;
50089 void *argp1 = 0 ;
50090 int res1 = 0 ;
50091 PyObject *swig_obj[1] ;
50092
50093 if (!args) SWIG_fail;
50094 swig_obj[0] = args;
50095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50096 if (!SWIG_IsOK(res1)) {
50097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
50098 }
50099 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50100 {
50101 PyThreadState* __tstate = wxPyBeginAllowThreads();
50102 result = (int)((wxGBPosition const *)arg1)->GetCol();
50103 wxPyEndAllowThreads(__tstate);
50104 if (PyErr_Occurred()) SWIG_fail;
50105 }
50106 resultobj = SWIG_From_int(static_cast< int >(result));
50107 return resultobj;
50108 fail:
50109 return NULL;
50110 }
50111
50112
50113 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50114 PyObject *resultobj = 0;
50115 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50116 int arg2 ;
50117 void *argp1 = 0 ;
50118 int res1 = 0 ;
50119 int val2 ;
50120 int ecode2 = 0 ;
50121 PyObject * obj0 = 0 ;
50122 PyObject * obj1 = 0 ;
50123 char * kwnames[] = {
50124 (char *) "self",(char *) "row", NULL
50125 };
50126
50127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
50128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50129 if (!SWIG_IsOK(res1)) {
50130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50131 }
50132 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50133 ecode2 = SWIG_AsVal_int(obj1, &val2);
50134 if (!SWIG_IsOK(ecode2)) {
50135 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
50136 }
50137 arg2 = static_cast< int >(val2);
50138 {
50139 PyThreadState* __tstate = wxPyBeginAllowThreads();
50140 (arg1)->SetRow(arg2);
50141 wxPyEndAllowThreads(__tstate);
50142 if (PyErr_Occurred()) SWIG_fail;
50143 }
50144 resultobj = SWIG_Py_Void();
50145 return resultobj;
50146 fail:
50147 return NULL;
50148 }
50149
50150
50151 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50152 PyObject *resultobj = 0;
50153 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50154 int arg2 ;
50155 void *argp1 = 0 ;
50156 int res1 = 0 ;
50157 int val2 ;
50158 int ecode2 = 0 ;
50159 PyObject * obj0 = 0 ;
50160 PyObject * obj1 = 0 ;
50161 char * kwnames[] = {
50162 (char *) "self",(char *) "col", NULL
50163 };
50164
50165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
50166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50167 if (!SWIG_IsOK(res1)) {
50168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50169 }
50170 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50171 ecode2 = SWIG_AsVal_int(obj1, &val2);
50172 if (!SWIG_IsOK(ecode2)) {
50173 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
50174 }
50175 arg2 = static_cast< int >(val2);
50176 {
50177 PyThreadState* __tstate = wxPyBeginAllowThreads();
50178 (arg1)->SetCol(arg2);
50179 wxPyEndAllowThreads(__tstate);
50180 if (PyErr_Occurred()) SWIG_fail;
50181 }
50182 resultobj = SWIG_Py_Void();
50183 return resultobj;
50184 fail:
50185 return NULL;
50186 }
50187
50188
50189 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50190 PyObject *resultobj = 0;
50191 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50192 PyObject *arg2 = (PyObject *) 0 ;
50193 bool result;
50194 void *argp1 = 0 ;
50195 int res1 = 0 ;
50196 PyObject * obj0 = 0 ;
50197 PyObject * obj1 = 0 ;
50198 char * kwnames[] = {
50199 (char *) "self",(char *) "other", NULL
50200 };
50201
50202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
50203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50204 if (!SWIG_IsOK(res1)) {
50205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50206 }
50207 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50208 arg2 = obj1;
50209 {
50210 result = (bool)wxGBPosition___eq__(arg1,arg2);
50211 if (PyErr_Occurred()) SWIG_fail;
50212 }
50213 {
50214 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50215 }
50216 return resultobj;
50217 fail:
50218 return NULL;
50219 }
50220
50221
50222 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50223 PyObject *resultobj = 0;
50224 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50225 PyObject *arg2 = (PyObject *) 0 ;
50226 bool result;
50227 void *argp1 = 0 ;
50228 int res1 = 0 ;
50229 PyObject * obj0 = 0 ;
50230 PyObject * obj1 = 0 ;
50231 char * kwnames[] = {
50232 (char *) "self",(char *) "other", NULL
50233 };
50234
50235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
50236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50237 if (!SWIG_IsOK(res1)) {
50238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50239 }
50240 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50241 arg2 = obj1;
50242 {
50243 result = (bool)wxGBPosition___ne__(arg1,arg2);
50244 if (PyErr_Occurred()) SWIG_fail;
50245 }
50246 {
50247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50248 }
50249 return resultobj;
50250 fail:
50251 return NULL;
50252 }
50253
50254
50255 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50256 PyObject *resultobj = 0;
50257 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50258 int arg2 = (int) 0 ;
50259 int arg3 = (int) 0 ;
50260 void *argp1 = 0 ;
50261 int res1 = 0 ;
50262 int val2 ;
50263 int ecode2 = 0 ;
50264 int val3 ;
50265 int ecode3 = 0 ;
50266 PyObject * obj0 = 0 ;
50267 PyObject * obj1 = 0 ;
50268 PyObject * obj2 = 0 ;
50269 char * kwnames[] = {
50270 (char *) "self",(char *) "row",(char *) "col", NULL
50271 };
50272
50273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50275 if (!SWIG_IsOK(res1)) {
50276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50277 }
50278 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50279 if (obj1) {
50280 ecode2 = SWIG_AsVal_int(obj1, &val2);
50281 if (!SWIG_IsOK(ecode2)) {
50282 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
50283 }
50284 arg2 = static_cast< int >(val2);
50285 }
50286 if (obj2) {
50287 ecode3 = SWIG_AsVal_int(obj2, &val3);
50288 if (!SWIG_IsOK(ecode3)) {
50289 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
50290 }
50291 arg3 = static_cast< int >(val3);
50292 }
50293 {
50294 PyThreadState* __tstate = wxPyBeginAllowThreads();
50295 wxGBPosition_Set(arg1,arg2,arg3);
50296 wxPyEndAllowThreads(__tstate);
50297 if (PyErr_Occurred()) SWIG_fail;
50298 }
50299 resultobj = SWIG_Py_Void();
50300 return resultobj;
50301 fail:
50302 return NULL;
50303 }
50304
50305
50306 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50307 PyObject *resultobj = 0;
50308 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50309 PyObject *result = 0 ;
50310 void *argp1 = 0 ;
50311 int res1 = 0 ;
50312 PyObject *swig_obj[1] ;
50313
50314 if (!args) SWIG_fail;
50315 swig_obj[0] = args;
50316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50317 if (!SWIG_IsOK(res1)) {
50318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50319 }
50320 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50321 {
50322 PyThreadState* __tstate = wxPyBeginAllowThreads();
50323 result = (PyObject *)wxGBPosition_Get(arg1);
50324 wxPyEndAllowThreads(__tstate);
50325 if (PyErr_Occurred()) SWIG_fail;
50326 }
50327 resultobj = result;
50328 return resultobj;
50329 fail:
50330 return NULL;
50331 }
50332
50333
50334 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50335 PyObject *obj;
50336 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50337 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
50338 return SWIG_Py_Void();
50339 }
50340
50341 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50342 return SWIG_Python_InitShadowInstance(args);
50343 }
50344
50345 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50346 PyObject *resultobj = 0;
50347 int arg1 = (int) 1 ;
50348 int arg2 = (int) 1 ;
50349 wxGBSpan *result = 0 ;
50350 int val1 ;
50351 int ecode1 = 0 ;
50352 int val2 ;
50353 int ecode2 = 0 ;
50354 PyObject * obj0 = 0 ;
50355 PyObject * obj1 = 0 ;
50356 char * kwnames[] = {
50357 (char *) "rowspan",(char *) "colspan", NULL
50358 };
50359
50360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
50361 if (obj0) {
50362 ecode1 = SWIG_AsVal_int(obj0, &val1);
50363 if (!SWIG_IsOK(ecode1)) {
50364 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
50365 }
50366 arg1 = static_cast< int >(val1);
50367 }
50368 if (obj1) {
50369 ecode2 = SWIG_AsVal_int(obj1, &val2);
50370 if (!SWIG_IsOK(ecode2)) {
50371 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
50372 }
50373 arg2 = static_cast< int >(val2);
50374 }
50375 {
50376 PyThreadState* __tstate = wxPyBeginAllowThreads();
50377 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
50378 wxPyEndAllowThreads(__tstate);
50379 if (PyErr_Occurred()) SWIG_fail;
50380 }
50381 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
50382 return resultobj;
50383 fail:
50384 return NULL;
50385 }
50386
50387
50388 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50389 PyObject *resultobj = 0;
50390 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50391 void *argp1 = 0 ;
50392 int res1 = 0 ;
50393 PyObject *swig_obj[1] ;
50394
50395 if (!args) SWIG_fail;
50396 swig_obj[0] = args;
50397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
50398 if (!SWIG_IsOK(res1)) {
50399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50400 }
50401 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50402 {
50403 PyThreadState* __tstate = wxPyBeginAllowThreads();
50404 delete arg1;
50405
50406 wxPyEndAllowThreads(__tstate);
50407 if (PyErr_Occurred()) SWIG_fail;
50408 }
50409 resultobj = SWIG_Py_Void();
50410 return resultobj;
50411 fail:
50412 return NULL;
50413 }
50414
50415
50416 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50417 PyObject *resultobj = 0;
50418 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50419 int result;
50420 void *argp1 = 0 ;
50421 int res1 = 0 ;
50422 PyObject *swig_obj[1] ;
50423
50424 if (!args) SWIG_fail;
50425 swig_obj[0] = args;
50426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50427 if (!SWIG_IsOK(res1)) {
50428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
50429 }
50430 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50431 {
50432 PyThreadState* __tstate = wxPyBeginAllowThreads();
50433 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
50434 wxPyEndAllowThreads(__tstate);
50435 if (PyErr_Occurred()) SWIG_fail;
50436 }
50437 resultobj = SWIG_From_int(static_cast< int >(result));
50438 return resultobj;
50439 fail:
50440 return NULL;
50441 }
50442
50443
50444 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50445 PyObject *resultobj = 0;
50446 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50447 int result;
50448 void *argp1 = 0 ;
50449 int res1 = 0 ;
50450 PyObject *swig_obj[1] ;
50451
50452 if (!args) SWIG_fail;
50453 swig_obj[0] = args;
50454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50455 if (!SWIG_IsOK(res1)) {
50456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
50457 }
50458 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50459 {
50460 PyThreadState* __tstate = wxPyBeginAllowThreads();
50461 result = (int)((wxGBSpan const *)arg1)->GetColspan();
50462 wxPyEndAllowThreads(__tstate);
50463 if (PyErr_Occurred()) SWIG_fail;
50464 }
50465 resultobj = SWIG_From_int(static_cast< int >(result));
50466 return resultobj;
50467 fail:
50468 return NULL;
50469 }
50470
50471
50472 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50473 PyObject *resultobj = 0;
50474 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50475 int arg2 ;
50476 void *argp1 = 0 ;
50477 int res1 = 0 ;
50478 int val2 ;
50479 int ecode2 = 0 ;
50480 PyObject * obj0 = 0 ;
50481 PyObject * obj1 = 0 ;
50482 char * kwnames[] = {
50483 (char *) "self",(char *) "rowspan", NULL
50484 };
50485
50486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
50487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50488 if (!SWIG_IsOK(res1)) {
50489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50490 }
50491 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50492 ecode2 = SWIG_AsVal_int(obj1, &val2);
50493 if (!SWIG_IsOK(ecode2)) {
50494 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
50495 }
50496 arg2 = static_cast< int >(val2);
50497 {
50498 PyThreadState* __tstate = wxPyBeginAllowThreads();
50499 (arg1)->SetRowspan(arg2);
50500 wxPyEndAllowThreads(__tstate);
50501 if (PyErr_Occurred()) SWIG_fail;
50502 }
50503 resultobj = SWIG_Py_Void();
50504 return resultobj;
50505 fail:
50506 return NULL;
50507 }
50508
50509
50510 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50511 PyObject *resultobj = 0;
50512 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50513 int arg2 ;
50514 void *argp1 = 0 ;
50515 int res1 = 0 ;
50516 int val2 ;
50517 int ecode2 = 0 ;
50518 PyObject * obj0 = 0 ;
50519 PyObject * obj1 = 0 ;
50520 char * kwnames[] = {
50521 (char *) "self",(char *) "colspan", NULL
50522 };
50523
50524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
50525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50526 if (!SWIG_IsOK(res1)) {
50527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50528 }
50529 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50530 ecode2 = SWIG_AsVal_int(obj1, &val2);
50531 if (!SWIG_IsOK(ecode2)) {
50532 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
50533 }
50534 arg2 = static_cast< int >(val2);
50535 {
50536 PyThreadState* __tstate = wxPyBeginAllowThreads();
50537 (arg1)->SetColspan(arg2);
50538 wxPyEndAllowThreads(__tstate);
50539 if (PyErr_Occurred()) SWIG_fail;
50540 }
50541 resultobj = SWIG_Py_Void();
50542 return resultobj;
50543 fail:
50544 return NULL;
50545 }
50546
50547
50548 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50549 PyObject *resultobj = 0;
50550 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50551 PyObject *arg2 = (PyObject *) 0 ;
50552 bool result;
50553 void *argp1 = 0 ;
50554 int res1 = 0 ;
50555 PyObject * obj0 = 0 ;
50556 PyObject * obj1 = 0 ;
50557 char * kwnames[] = {
50558 (char *) "self",(char *) "other", NULL
50559 };
50560
50561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
50562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50563 if (!SWIG_IsOK(res1)) {
50564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50565 }
50566 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50567 arg2 = obj1;
50568 {
50569 result = (bool)wxGBSpan___eq__(arg1,arg2);
50570 if (PyErr_Occurred()) SWIG_fail;
50571 }
50572 {
50573 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50574 }
50575 return resultobj;
50576 fail:
50577 return NULL;
50578 }
50579
50580
50581 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50582 PyObject *resultobj = 0;
50583 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50584 PyObject *arg2 = (PyObject *) 0 ;
50585 bool result;
50586 void *argp1 = 0 ;
50587 int res1 = 0 ;
50588 PyObject * obj0 = 0 ;
50589 PyObject * obj1 = 0 ;
50590 char * kwnames[] = {
50591 (char *) "self",(char *) "other", NULL
50592 };
50593
50594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
50595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50596 if (!SWIG_IsOK(res1)) {
50597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50598 }
50599 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50600 arg2 = obj1;
50601 {
50602 result = (bool)wxGBSpan___ne__(arg1,arg2);
50603 if (PyErr_Occurred()) SWIG_fail;
50604 }
50605 {
50606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50607 }
50608 return resultobj;
50609 fail:
50610 return NULL;
50611 }
50612
50613
50614 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50615 PyObject *resultobj = 0;
50616 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50617 int arg2 = (int) 1 ;
50618 int arg3 = (int) 1 ;
50619 void *argp1 = 0 ;
50620 int res1 = 0 ;
50621 int val2 ;
50622 int ecode2 = 0 ;
50623 int val3 ;
50624 int ecode3 = 0 ;
50625 PyObject * obj0 = 0 ;
50626 PyObject * obj1 = 0 ;
50627 PyObject * obj2 = 0 ;
50628 char * kwnames[] = {
50629 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
50630 };
50631
50632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50634 if (!SWIG_IsOK(res1)) {
50635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50636 }
50637 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50638 if (obj1) {
50639 ecode2 = SWIG_AsVal_int(obj1, &val2);
50640 if (!SWIG_IsOK(ecode2)) {
50641 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
50642 }
50643 arg2 = static_cast< int >(val2);
50644 }
50645 if (obj2) {
50646 ecode3 = SWIG_AsVal_int(obj2, &val3);
50647 if (!SWIG_IsOK(ecode3)) {
50648 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
50649 }
50650 arg3 = static_cast< int >(val3);
50651 }
50652 {
50653 PyThreadState* __tstate = wxPyBeginAllowThreads();
50654 wxGBSpan_Set(arg1,arg2,arg3);
50655 wxPyEndAllowThreads(__tstate);
50656 if (PyErr_Occurred()) SWIG_fail;
50657 }
50658 resultobj = SWIG_Py_Void();
50659 return resultobj;
50660 fail:
50661 return NULL;
50662 }
50663
50664
50665 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50666 PyObject *resultobj = 0;
50667 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50668 PyObject *result = 0 ;
50669 void *argp1 = 0 ;
50670 int res1 = 0 ;
50671 PyObject *swig_obj[1] ;
50672
50673 if (!args) SWIG_fail;
50674 swig_obj[0] = args;
50675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50676 if (!SWIG_IsOK(res1)) {
50677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50678 }
50679 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50680 {
50681 PyThreadState* __tstate = wxPyBeginAllowThreads();
50682 result = (PyObject *)wxGBSpan_Get(arg1);
50683 wxPyEndAllowThreads(__tstate);
50684 if (PyErr_Occurred()) SWIG_fail;
50685 }
50686 resultobj = result;
50687 return resultobj;
50688 fail:
50689 return NULL;
50690 }
50691
50692
50693 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50694 PyObject *obj;
50695 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50696 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
50697 return SWIG_Py_Void();
50698 }
50699
50700 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50701 return SWIG_Python_InitShadowInstance(args);
50702 }
50703
50704 SWIGINTERN int DefaultSpan_set(PyObject *) {
50705 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
50706 return 1;
50707 }
50708
50709
50710 SWIGINTERN PyObject *DefaultSpan_get(void) {
50711 PyObject *pyobj = 0;
50712
50713 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
50714 return pyobj;
50715 }
50716
50717
50718 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50719 PyObject *resultobj = 0;
50720 wxGBSizerItem *result = 0 ;
50721
50722 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
50723 {
50724 PyThreadState* __tstate = wxPyBeginAllowThreads();
50725 result = (wxGBSizerItem *)new wxGBSizerItem();
50726 wxPyEndAllowThreads(__tstate);
50727 if (PyErr_Occurred()) SWIG_fail;
50728 }
50729 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
50730 return resultobj;
50731 fail:
50732 return NULL;
50733 }
50734
50735
50736 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50737 PyObject *resultobj = 0;
50738 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50739 void *argp1 = 0 ;
50740 int res1 = 0 ;
50741 PyObject *swig_obj[1] ;
50742
50743 if (!args) SWIG_fail;
50744 swig_obj[0] = args;
50745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
50746 if (!SWIG_IsOK(res1)) {
50747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50748 }
50749 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50750 {
50751 PyThreadState* __tstate = wxPyBeginAllowThreads();
50752 delete arg1;
50753
50754 wxPyEndAllowThreads(__tstate);
50755 if (PyErr_Occurred()) SWIG_fail;
50756 }
50757 resultobj = SWIG_Py_Void();
50758 return resultobj;
50759 fail:
50760 return NULL;
50761 }
50762
50763
50764 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50765 PyObject *resultobj = 0;
50766 wxWindow *arg1 = (wxWindow *) 0 ;
50767 wxGBPosition *arg2 = 0 ;
50768 wxGBSpan *arg3 = 0 ;
50769 int arg4 ;
50770 int arg5 ;
50771 PyObject *arg6 = (PyObject *) NULL ;
50772 wxGBSizerItem *result = 0 ;
50773 void *argp1 = 0 ;
50774 int res1 = 0 ;
50775 wxGBPosition temp2 ;
50776 wxGBSpan temp3 ;
50777 int val4 ;
50778 int ecode4 = 0 ;
50779 int val5 ;
50780 int ecode5 = 0 ;
50781 PyObject * obj0 = 0 ;
50782 PyObject * obj1 = 0 ;
50783 PyObject * obj2 = 0 ;
50784 PyObject * obj3 = 0 ;
50785 PyObject * obj4 = 0 ;
50786 PyObject * obj5 = 0 ;
50787 char * kwnames[] = {
50788 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50789 };
50790
50791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
50792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
50793 if (!SWIG_IsOK(res1)) {
50794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
50795 }
50796 arg1 = reinterpret_cast< wxWindow * >(argp1);
50797 {
50798 arg2 = &temp2;
50799 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50800 }
50801 {
50802 arg3 = &temp3;
50803 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50804 }
50805 ecode4 = SWIG_AsVal_int(obj3, &val4);
50806 if (!SWIG_IsOK(ecode4)) {
50807 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
50808 }
50809 arg4 = static_cast< int >(val4);
50810 ecode5 = SWIG_AsVal_int(obj4, &val5);
50811 if (!SWIG_IsOK(ecode5)) {
50812 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
50813 }
50814 arg5 = static_cast< int >(val5);
50815 if (obj5) {
50816 arg6 = obj5;
50817 }
50818 {
50819 PyThreadState* __tstate = wxPyBeginAllowThreads();
50820 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
50821 wxPyEndAllowThreads(__tstate);
50822 if (PyErr_Occurred()) SWIG_fail;
50823 }
50824 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
50825 return resultobj;
50826 fail:
50827 return NULL;
50828 }
50829
50830
50831 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50832 PyObject *resultobj = 0;
50833 wxSizer *arg1 = (wxSizer *) 0 ;
50834 wxGBPosition *arg2 = 0 ;
50835 wxGBSpan *arg3 = 0 ;
50836 int arg4 ;
50837 int arg5 ;
50838 PyObject *arg6 = (PyObject *) NULL ;
50839 wxGBSizerItem *result = 0 ;
50840 int res1 = 0 ;
50841 wxGBPosition temp2 ;
50842 wxGBSpan temp3 ;
50843 int val4 ;
50844 int ecode4 = 0 ;
50845 int val5 ;
50846 int ecode5 = 0 ;
50847 PyObject * obj0 = 0 ;
50848 PyObject * obj1 = 0 ;
50849 PyObject * obj2 = 0 ;
50850 PyObject * obj3 = 0 ;
50851 PyObject * obj4 = 0 ;
50852 PyObject * obj5 = 0 ;
50853 char * kwnames[] = {
50854 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50855 };
50856
50857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
50858 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
50859 if (!SWIG_IsOK(res1)) {
50860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
50861 }
50862 {
50863 arg2 = &temp2;
50864 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50865 }
50866 {
50867 arg3 = &temp3;
50868 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50869 }
50870 ecode4 = SWIG_AsVal_int(obj3, &val4);
50871 if (!SWIG_IsOK(ecode4)) {
50872 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
50873 }
50874 arg4 = static_cast< int >(val4);
50875 ecode5 = SWIG_AsVal_int(obj4, &val5);
50876 if (!SWIG_IsOK(ecode5)) {
50877 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
50878 }
50879 arg5 = static_cast< int >(val5);
50880 if (obj5) {
50881 arg6 = obj5;
50882 }
50883 {
50884 PyThreadState* __tstate = wxPyBeginAllowThreads();
50885 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
50886 wxPyEndAllowThreads(__tstate);
50887 if (PyErr_Occurred()) SWIG_fail;
50888 }
50889 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
50890 return resultobj;
50891 fail:
50892 return NULL;
50893 }
50894
50895
50896 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50897 PyObject *resultobj = 0;
50898 int arg1 ;
50899 int arg2 ;
50900 wxGBPosition *arg3 = 0 ;
50901 wxGBSpan *arg4 = 0 ;
50902 int arg5 ;
50903 int arg6 ;
50904 PyObject *arg7 = (PyObject *) NULL ;
50905 wxGBSizerItem *result = 0 ;
50906 int val1 ;
50907 int ecode1 = 0 ;
50908 int val2 ;
50909 int ecode2 = 0 ;
50910 wxGBPosition temp3 ;
50911 wxGBSpan temp4 ;
50912 int val5 ;
50913 int ecode5 = 0 ;
50914 int val6 ;
50915 int ecode6 = 0 ;
50916 PyObject * obj0 = 0 ;
50917 PyObject * obj1 = 0 ;
50918 PyObject * obj2 = 0 ;
50919 PyObject * obj3 = 0 ;
50920 PyObject * obj4 = 0 ;
50921 PyObject * obj5 = 0 ;
50922 PyObject * obj6 = 0 ;
50923 char * kwnames[] = {
50924 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50925 };
50926
50927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
50928 ecode1 = SWIG_AsVal_int(obj0, &val1);
50929 if (!SWIG_IsOK(ecode1)) {
50930 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
50931 }
50932 arg1 = static_cast< int >(val1);
50933 ecode2 = SWIG_AsVal_int(obj1, &val2);
50934 if (!SWIG_IsOK(ecode2)) {
50935 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
50936 }
50937 arg2 = static_cast< int >(val2);
50938 {
50939 arg3 = &temp3;
50940 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
50941 }
50942 {
50943 arg4 = &temp4;
50944 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
50945 }
50946 ecode5 = SWIG_AsVal_int(obj4, &val5);
50947 if (!SWIG_IsOK(ecode5)) {
50948 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
50949 }
50950 arg5 = static_cast< int >(val5);
50951 ecode6 = SWIG_AsVal_int(obj5, &val6);
50952 if (!SWIG_IsOK(ecode6)) {
50953 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
50954 }
50955 arg6 = static_cast< int >(val6);
50956 if (obj6) {
50957 arg7 = obj6;
50958 }
50959 {
50960 PyThreadState* __tstate = wxPyBeginAllowThreads();
50961 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
50962 wxPyEndAllowThreads(__tstate);
50963 if (PyErr_Occurred()) SWIG_fail;
50964 }
50965 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
50966 return resultobj;
50967 fail:
50968 return NULL;
50969 }
50970
50971
50972 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50973 PyObject *resultobj = 0;
50974 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50975 wxGBPosition result;
50976 void *argp1 = 0 ;
50977 int res1 = 0 ;
50978 PyObject *swig_obj[1] ;
50979
50980 if (!args) SWIG_fail;
50981 swig_obj[0] = args;
50982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50983 if (!SWIG_IsOK(res1)) {
50984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50985 }
50986 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50987 {
50988 PyThreadState* __tstate = wxPyBeginAllowThreads();
50989 result = ((wxGBSizerItem const *)arg1)->GetPos();
50990 wxPyEndAllowThreads(__tstate);
50991 if (PyErr_Occurred()) SWIG_fail;
50992 }
50993 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50994 return resultobj;
50995 fail:
50996 return NULL;
50997 }
50998
50999
51000 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51001 PyObject *resultobj = 0;
51002 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51003 wxGBSpan result;
51004 void *argp1 = 0 ;
51005 int res1 = 0 ;
51006 PyObject *swig_obj[1] ;
51007
51008 if (!args) SWIG_fail;
51009 swig_obj[0] = args;
51010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51011 if (!SWIG_IsOK(res1)) {
51012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
51013 }
51014 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51015 {
51016 PyThreadState* __tstate = wxPyBeginAllowThreads();
51017 result = ((wxGBSizerItem const *)arg1)->GetSpan();
51018 wxPyEndAllowThreads(__tstate);
51019 if (PyErr_Occurred()) SWIG_fail;
51020 }
51021 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51022 return resultobj;
51023 fail:
51024 return NULL;
51025 }
51026
51027
51028 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51029 PyObject *resultobj = 0;
51030 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51031 wxGBPosition *arg2 = 0 ;
51032 bool result;
51033 void *argp1 = 0 ;
51034 int res1 = 0 ;
51035 wxGBPosition temp2 ;
51036 PyObject * obj0 = 0 ;
51037 PyObject * obj1 = 0 ;
51038 char * kwnames[] = {
51039 (char *) "self",(char *) "pos", NULL
51040 };
51041
51042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
51043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51044 if (!SWIG_IsOK(res1)) {
51045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51046 }
51047 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51048 {
51049 arg2 = &temp2;
51050 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51051 }
51052 {
51053 PyThreadState* __tstate = wxPyBeginAllowThreads();
51054 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
51055 wxPyEndAllowThreads(__tstate);
51056 if (PyErr_Occurred()) SWIG_fail;
51057 }
51058 {
51059 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51060 }
51061 return resultobj;
51062 fail:
51063 return NULL;
51064 }
51065
51066
51067 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51068 PyObject *resultobj = 0;
51069 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51070 wxGBSpan *arg2 = 0 ;
51071 bool result;
51072 void *argp1 = 0 ;
51073 int res1 = 0 ;
51074 wxGBSpan temp2 ;
51075 PyObject * obj0 = 0 ;
51076 PyObject * obj1 = 0 ;
51077 char * kwnames[] = {
51078 (char *) "self",(char *) "span", NULL
51079 };
51080
51081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
51082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51083 if (!SWIG_IsOK(res1)) {
51084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51085 }
51086 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51087 {
51088 arg2 = &temp2;
51089 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
51090 }
51091 {
51092 PyThreadState* __tstate = wxPyBeginAllowThreads();
51093 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
51094 wxPyEndAllowThreads(__tstate);
51095 if (PyErr_Occurred()) SWIG_fail;
51096 }
51097 {
51098 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51099 }
51100 return resultobj;
51101 fail:
51102 return NULL;
51103 }
51104
51105
51106 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51107 PyObject *resultobj = 0;
51108 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51109 wxGBSizerItem *arg2 = 0 ;
51110 bool result;
51111 void *argp1 = 0 ;
51112 int res1 = 0 ;
51113 void *argp2 = 0 ;
51114 int res2 = 0 ;
51115 PyObject * obj0 = 0 ;
51116 PyObject * obj1 = 0 ;
51117 char * kwnames[] = {
51118 (char *) "self",(char *) "other", NULL
51119 };
51120
51121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
51122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51123 if (!SWIG_IsOK(res1)) {
51124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51125 }
51126 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51127 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
51128 if (!SWIG_IsOK(res2)) {
51129 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
51130 }
51131 if (!argp2) {
51132 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
51133 }
51134 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
51135 {
51136 PyThreadState* __tstate = wxPyBeginAllowThreads();
51137 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
51138 wxPyEndAllowThreads(__tstate);
51139 if (PyErr_Occurred()) SWIG_fail;
51140 }
51141 {
51142 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51143 }
51144 return resultobj;
51145 fail:
51146 return NULL;
51147 }
51148
51149
51150 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51151 PyObject *resultobj = 0;
51152 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51153 wxGBPosition *arg2 = 0 ;
51154 wxGBSpan *arg3 = 0 ;
51155 bool result;
51156 void *argp1 = 0 ;
51157 int res1 = 0 ;
51158 wxGBPosition temp2 ;
51159 wxGBSpan temp3 ;
51160 PyObject * obj0 = 0 ;
51161 PyObject * obj1 = 0 ;
51162 PyObject * obj2 = 0 ;
51163 char * kwnames[] = {
51164 (char *) "self",(char *) "pos",(char *) "span", NULL
51165 };
51166
51167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51169 if (!SWIG_IsOK(res1)) {
51170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51171 }
51172 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51173 {
51174 arg2 = &temp2;
51175 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51176 }
51177 {
51178 arg3 = &temp3;
51179 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51180 }
51181 {
51182 PyThreadState* __tstate = wxPyBeginAllowThreads();
51183 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
51184 wxPyEndAllowThreads(__tstate);
51185 if (PyErr_Occurred()) SWIG_fail;
51186 }
51187 {
51188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51189 }
51190 return resultobj;
51191 fail:
51192 return NULL;
51193 }
51194
51195
51196 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51197 PyObject *resultobj = 0;
51198 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51199 wxGBPosition result;
51200 void *argp1 = 0 ;
51201 int res1 = 0 ;
51202 PyObject *swig_obj[1] ;
51203
51204 if (!args) SWIG_fail;
51205 swig_obj[0] = args;
51206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51207 if (!SWIG_IsOK(res1)) {
51208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51209 }
51210 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51211 {
51212 PyThreadState* __tstate = wxPyBeginAllowThreads();
51213 result = wxGBSizerItem_GetEndPos(arg1);
51214 wxPyEndAllowThreads(__tstate);
51215 if (PyErr_Occurred()) SWIG_fail;
51216 }
51217 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51218 return resultobj;
51219 fail:
51220 return NULL;
51221 }
51222
51223
51224 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51225 PyObject *resultobj = 0;
51226 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51227 wxGridBagSizer *result = 0 ;
51228 void *argp1 = 0 ;
51229 int res1 = 0 ;
51230 PyObject *swig_obj[1] ;
51231
51232 if (!args) SWIG_fail;
51233 swig_obj[0] = args;
51234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51235 if (!SWIG_IsOK(res1)) {
51236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
51237 }
51238 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51239 {
51240 PyThreadState* __tstate = wxPyBeginAllowThreads();
51241 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
51242 wxPyEndAllowThreads(__tstate);
51243 if (PyErr_Occurred()) SWIG_fail;
51244 }
51245 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51246 return resultobj;
51247 fail:
51248 return NULL;
51249 }
51250
51251
51252 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51253 PyObject *resultobj = 0;
51254 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51255 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
51256 void *argp1 = 0 ;
51257 int res1 = 0 ;
51258 void *argp2 = 0 ;
51259 int res2 = 0 ;
51260 PyObject * obj0 = 0 ;
51261 PyObject * obj1 = 0 ;
51262 char * kwnames[] = {
51263 (char *) "self",(char *) "sizer", NULL
51264 };
51265
51266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51268 if (!SWIG_IsOK(res1)) {
51269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51270 }
51271 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51272 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51273 if (!SWIG_IsOK(res2)) {
51274 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
51275 }
51276 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
51277 {
51278 PyThreadState* __tstate = wxPyBeginAllowThreads();
51279 (arg1)->SetGBSizer(arg2);
51280 wxPyEndAllowThreads(__tstate);
51281 if (PyErr_Occurred()) SWIG_fail;
51282 }
51283 resultobj = SWIG_Py_Void();
51284 return resultobj;
51285 fail:
51286 return NULL;
51287 }
51288
51289
51290 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51291 PyObject *obj;
51292 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51293 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
51294 return SWIG_Py_Void();
51295 }
51296
51297 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51298 return SWIG_Python_InitShadowInstance(args);
51299 }
51300
51301 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51302 PyObject *resultobj = 0;
51303 int arg1 = (int) 0 ;
51304 int arg2 = (int) 0 ;
51305 wxGridBagSizer *result = 0 ;
51306 int val1 ;
51307 int ecode1 = 0 ;
51308 int val2 ;
51309 int ecode2 = 0 ;
51310 PyObject * obj0 = 0 ;
51311 PyObject * obj1 = 0 ;
51312 char * kwnames[] = {
51313 (char *) "vgap",(char *) "hgap", NULL
51314 };
51315
51316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51317 if (obj0) {
51318 ecode1 = SWIG_AsVal_int(obj0, &val1);
51319 if (!SWIG_IsOK(ecode1)) {
51320 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
51321 }
51322 arg1 = static_cast< int >(val1);
51323 }
51324 if (obj1) {
51325 ecode2 = SWIG_AsVal_int(obj1, &val2);
51326 if (!SWIG_IsOK(ecode2)) {
51327 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
51328 }
51329 arg2 = static_cast< int >(val2);
51330 }
51331 {
51332 PyThreadState* __tstate = wxPyBeginAllowThreads();
51333 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
51334 wxPyEndAllowThreads(__tstate);
51335 if (PyErr_Occurred()) SWIG_fail;
51336 }
51337 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
51338 return resultobj;
51339 fail:
51340 return NULL;
51341 }
51342
51343
51344 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51345 PyObject *resultobj = 0;
51346 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51347 PyObject *arg2 = (PyObject *) 0 ;
51348 wxGBPosition *arg3 = 0 ;
51349 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
51350 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
51351 int arg5 = (int) 0 ;
51352 int arg6 = (int) 0 ;
51353 PyObject *arg7 = (PyObject *) NULL ;
51354 wxGBSizerItem *result = 0 ;
51355 void *argp1 = 0 ;
51356 int res1 = 0 ;
51357 wxGBPosition temp3 ;
51358 wxGBSpan temp4 ;
51359 int val5 ;
51360 int ecode5 = 0 ;
51361 int val6 ;
51362 int ecode6 = 0 ;
51363 PyObject * obj0 = 0 ;
51364 PyObject * obj1 = 0 ;
51365 PyObject * obj2 = 0 ;
51366 PyObject * obj3 = 0 ;
51367 PyObject * obj4 = 0 ;
51368 PyObject * obj5 = 0 ;
51369 PyObject * obj6 = 0 ;
51370 char * kwnames[] = {
51371 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
51372 };
51373
51374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
51375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51376 if (!SWIG_IsOK(res1)) {
51377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51378 }
51379 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51380 arg2 = obj1;
51381 {
51382 arg3 = &temp3;
51383 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
51384 }
51385 if (obj3) {
51386 {
51387 arg4 = &temp4;
51388 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
51389 }
51390 }
51391 if (obj4) {
51392 ecode5 = SWIG_AsVal_int(obj4, &val5);
51393 if (!SWIG_IsOK(ecode5)) {
51394 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
51395 }
51396 arg5 = static_cast< int >(val5);
51397 }
51398 if (obj5) {
51399 ecode6 = SWIG_AsVal_int(obj5, &val6);
51400 if (!SWIG_IsOK(ecode6)) {
51401 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
51402 }
51403 arg6 = static_cast< int >(val6);
51404 }
51405 if (obj6) {
51406 arg7 = obj6;
51407 }
51408 {
51409 PyThreadState* __tstate = wxPyBeginAllowThreads();
51410 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
51411 wxPyEndAllowThreads(__tstate);
51412 if (PyErr_Occurred()) SWIG_fail;
51413 }
51414 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51415 return resultobj;
51416 fail:
51417 return NULL;
51418 }
51419
51420
51421 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51422 PyObject *resultobj = 0;
51423 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51424 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
51425 wxGBSizerItem *result = 0 ;
51426 void *argp1 = 0 ;
51427 int res1 = 0 ;
51428 int res2 = 0 ;
51429 PyObject * obj0 = 0 ;
51430 PyObject * obj1 = 0 ;
51431 char * kwnames[] = {
51432 (char *) "self",(char *) "item", NULL
51433 };
51434
51435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
51436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51437 if (!SWIG_IsOK(res1)) {
51438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51439 }
51440 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51441 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
51442 if (!SWIG_IsOK(res2)) {
51443 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51444 }
51445 {
51446 PyThreadState* __tstate = wxPyBeginAllowThreads();
51447 result = (wxGBSizerItem *)(arg1)->Add(arg2);
51448 wxPyEndAllowThreads(__tstate);
51449 if (PyErr_Occurred()) SWIG_fail;
51450 }
51451 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51452 return resultobj;
51453 fail:
51454 return NULL;
51455 }
51456
51457
51458 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51459 PyObject *resultobj = 0;
51460 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51461 int arg2 ;
51462 int arg3 ;
51463 wxSize result;
51464 void *argp1 = 0 ;
51465 int res1 = 0 ;
51466 int val2 ;
51467 int ecode2 = 0 ;
51468 int val3 ;
51469 int ecode3 = 0 ;
51470 PyObject * obj0 = 0 ;
51471 PyObject * obj1 = 0 ;
51472 PyObject * obj2 = 0 ;
51473 char * kwnames[] = {
51474 (char *) "self",(char *) "row",(char *) "col", NULL
51475 };
51476
51477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51479 if (!SWIG_IsOK(res1)) {
51480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
51481 }
51482 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51483 ecode2 = SWIG_AsVal_int(obj1, &val2);
51484 if (!SWIG_IsOK(ecode2)) {
51485 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
51486 }
51487 arg2 = static_cast< int >(val2);
51488 ecode3 = SWIG_AsVal_int(obj2, &val3);
51489 if (!SWIG_IsOK(ecode3)) {
51490 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
51491 }
51492 arg3 = static_cast< int >(val3);
51493 {
51494 PyThreadState* __tstate = wxPyBeginAllowThreads();
51495 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
51496 wxPyEndAllowThreads(__tstate);
51497 if (PyErr_Occurred()) SWIG_fail;
51498 }
51499 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
51500 return resultobj;
51501 fail:
51502 return NULL;
51503 }
51504
51505
51506 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51507 PyObject *resultobj = 0;
51508 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51509 wxSize result;
51510 void *argp1 = 0 ;
51511 int res1 = 0 ;
51512 PyObject *swig_obj[1] ;
51513
51514 if (!args) SWIG_fail;
51515 swig_obj[0] = args;
51516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51517 if (!SWIG_IsOK(res1)) {
51518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
51519 }
51520 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51521 {
51522 PyThreadState* __tstate = wxPyBeginAllowThreads();
51523 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
51524 wxPyEndAllowThreads(__tstate);
51525 if (PyErr_Occurred()) SWIG_fail;
51526 }
51527 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
51528 return resultobj;
51529 fail:
51530 return NULL;
51531 }
51532
51533
51534 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51535 PyObject *resultobj = 0;
51536 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51537 wxSize *arg2 = 0 ;
51538 void *argp1 = 0 ;
51539 int res1 = 0 ;
51540 wxSize temp2 ;
51541 PyObject * obj0 = 0 ;
51542 PyObject * obj1 = 0 ;
51543 char * kwnames[] = {
51544 (char *) "self",(char *) "sz", NULL
51545 };
51546
51547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
51548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51549 if (!SWIG_IsOK(res1)) {
51550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51551 }
51552 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51553 {
51554 arg2 = &temp2;
51555 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
51556 }
51557 {
51558 PyThreadState* __tstate = wxPyBeginAllowThreads();
51559 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
51560 wxPyEndAllowThreads(__tstate);
51561 if (PyErr_Occurred()) SWIG_fail;
51562 }
51563 resultobj = SWIG_Py_Void();
51564 return resultobj;
51565 fail:
51566 return NULL;
51567 }
51568
51569
51570 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51571 PyObject *resultobj = 0;
51572 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51573 wxWindow *arg2 = (wxWindow *) 0 ;
51574 wxGBPosition result;
51575 void *argp1 = 0 ;
51576 int res1 = 0 ;
51577 void *argp2 = 0 ;
51578 int res2 = 0 ;
51579
51580 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51582 if (!SWIG_IsOK(res1)) {
51583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51584 }
51585 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51586 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51587 if (!SWIG_IsOK(res2)) {
51588 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
51589 }
51590 arg2 = reinterpret_cast< wxWindow * >(argp2);
51591 {
51592 PyThreadState* __tstate = wxPyBeginAllowThreads();
51593 result = (arg1)->GetItemPosition(arg2);
51594 wxPyEndAllowThreads(__tstate);
51595 if (PyErr_Occurred()) SWIG_fail;
51596 }
51597 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51598 return resultobj;
51599 fail:
51600 return NULL;
51601 }
51602
51603
51604 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51605 PyObject *resultobj = 0;
51606 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51607 wxSizer *arg2 = (wxSizer *) 0 ;
51608 wxGBPosition result;
51609 void *argp1 = 0 ;
51610 int res1 = 0 ;
51611 void *argp2 = 0 ;
51612 int res2 = 0 ;
51613
51614 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51616 if (!SWIG_IsOK(res1)) {
51617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51618 }
51619 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51620 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51621 if (!SWIG_IsOK(res2)) {
51622 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
51623 }
51624 arg2 = reinterpret_cast< wxSizer * >(argp2);
51625 {
51626 PyThreadState* __tstate = wxPyBeginAllowThreads();
51627 result = (arg1)->GetItemPosition(arg2);
51628 wxPyEndAllowThreads(__tstate);
51629 if (PyErr_Occurred()) SWIG_fail;
51630 }
51631 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51632 return resultobj;
51633 fail:
51634 return NULL;
51635 }
51636
51637
51638 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51639 PyObject *resultobj = 0;
51640 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51641 size_t arg2 ;
51642 wxGBPosition result;
51643 void *argp1 = 0 ;
51644 int res1 = 0 ;
51645 size_t val2 ;
51646 int ecode2 = 0 ;
51647
51648 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51650 if (!SWIG_IsOK(res1)) {
51651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51652 }
51653 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51654 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51655 if (!SWIG_IsOK(ecode2)) {
51656 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
51657 }
51658 arg2 = static_cast< size_t >(val2);
51659 {
51660 PyThreadState* __tstate = wxPyBeginAllowThreads();
51661 result = (arg1)->GetItemPosition(arg2);
51662 wxPyEndAllowThreads(__tstate);
51663 if (PyErr_Occurred()) SWIG_fail;
51664 }
51665 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51666 return resultobj;
51667 fail:
51668 return NULL;
51669 }
51670
51671
51672 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
51673 int argc;
51674 PyObject *argv[3];
51675
51676 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
51677 --argc;
51678 if (argc == 2) {
51679 int _v = 0;
51680 {
51681 void *vptr = 0;
51682 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51683 _v = SWIG_CheckState(res);
51684 }
51685 if (!_v) goto check_1;
51686 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
51687 }
51688 check_1:
51689
51690 if (argc == 2) {
51691 int _v = 0;
51692 {
51693 void *vptr = 0;
51694 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51695 _v = SWIG_CheckState(res);
51696 }
51697 if (!_v) goto check_2;
51698 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
51699 }
51700 check_2:
51701
51702 if (argc == 2) {
51703 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
51704 }
51705
51706 fail:
51707 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
51708 return NULL;
51709 }
51710
51711
51712 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51713 PyObject *resultobj = 0;
51714 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51715 wxWindow *arg2 = (wxWindow *) 0 ;
51716 wxGBPosition *arg3 = 0 ;
51717 bool result;
51718 void *argp1 = 0 ;
51719 int res1 = 0 ;
51720 void *argp2 = 0 ;
51721 int res2 = 0 ;
51722 wxGBPosition temp3 ;
51723
51724 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51726 if (!SWIG_IsOK(res1)) {
51727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51728 }
51729 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51730 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51731 if (!SWIG_IsOK(res2)) {
51732 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
51733 }
51734 arg2 = reinterpret_cast< wxWindow * >(argp2);
51735 {
51736 arg3 = &temp3;
51737 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
51738 }
51739 {
51740 PyThreadState* __tstate = wxPyBeginAllowThreads();
51741 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
51742 wxPyEndAllowThreads(__tstate);
51743 if (PyErr_Occurred()) SWIG_fail;
51744 }
51745 {
51746 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51747 }
51748 return resultobj;
51749 fail:
51750 return NULL;
51751 }
51752
51753
51754 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51755 PyObject *resultobj = 0;
51756 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51757 wxSizer *arg2 = (wxSizer *) 0 ;
51758 wxGBPosition *arg3 = 0 ;
51759 bool result;
51760 void *argp1 = 0 ;
51761 int res1 = 0 ;
51762 void *argp2 = 0 ;
51763 int res2 = 0 ;
51764 wxGBPosition temp3 ;
51765
51766 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51768 if (!SWIG_IsOK(res1)) {
51769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51770 }
51771 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51772 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51773 if (!SWIG_IsOK(res2)) {
51774 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
51775 }
51776 arg2 = reinterpret_cast< wxSizer * >(argp2);
51777 {
51778 arg3 = &temp3;
51779 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
51780 }
51781 {
51782 PyThreadState* __tstate = wxPyBeginAllowThreads();
51783 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
51784 wxPyEndAllowThreads(__tstate);
51785 if (PyErr_Occurred()) SWIG_fail;
51786 }
51787 {
51788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51789 }
51790 return resultobj;
51791 fail:
51792 return NULL;
51793 }
51794
51795
51796 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51797 PyObject *resultobj = 0;
51798 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51799 size_t arg2 ;
51800 wxGBPosition *arg3 = 0 ;
51801 bool result;
51802 void *argp1 = 0 ;
51803 int res1 = 0 ;
51804 size_t val2 ;
51805 int ecode2 = 0 ;
51806 wxGBPosition temp3 ;
51807
51808 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51810 if (!SWIG_IsOK(res1)) {
51811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51812 }
51813 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51814 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51815 if (!SWIG_IsOK(ecode2)) {
51816 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
51817 }
51818 arg2 = static_cast< size_t >(val2);
51819 {
51820 arg3 = &temp3;
51821 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
51822 }
51823 {
51824 PyThreadState* __tstate = wxPyBeginAllowThreads();
51825 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
51826 wxPyEndAllowThreads(__tstate);
51827 if (PyErr_Occurred()) SWIG_fail;
51828 }
51829 {
51830 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51831 }
51832 return resultobj;
51833 fail:
51834 return NULL;
51835 }
51836
51837
51838 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
51839 int argc;
51840 PyObject *argv[4];
51841
51842 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
51843 --argc;
51844 if (argc == 3) {
51845 int _v = 0;
51846 {
51847 void *vptr = 0;
51848 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51849 _v = SWIG_CheckState(res);
51850 }
51851 if (!_v) goto check_1;
51852 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
51853 }
51854 check_1:
51855
51856 if (argc == 3) {
51857 int _v = 0;
51858 {
51859 void *vptr = 0;
51860 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51861 _v = SWIG_CheckState(res);
51862 }
51863 if (!_v) goto check_2;
51864 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
51865 }
51866 check_2:
51867
51868 if (argc == 3) {
51869 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
51870 }
51871
51872 fail:
51873 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
51874 return NULL;
51875 }
51876
51877
51878 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51879 PyObject *resultobj = 0;
51880 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51881 wxWindow *arg2 = (wxWindow *) 0 ;
51882 wxGBSpan result;
51883 void *argp1 = 0 ;
51884 int res1 = 0 ;
51885 void *argp2 = 0 ;
51886 int res2 = 0 ;
51887
51888 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51890 if (!SWIG_IsOK(res1)) {
51891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51892 }
51893 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51894 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51895 if (!SWIG_IsOK(res2)) {
51896 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
51897 }
51898 arg2 = reinterpret_cast< wxWindow * >(argp2);
51899 {
51900 PyThreadState* __tstate = wxPyBeginAllowThreads();
51901 result = (arg1)->GetItemSpan(arg2);
51902 wxPyEndAllowThreads(__tstate);
51903 if (PyErr_Occurred()) SWIG_fail;
51904 }
51905 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51906 return resultobj;
51907 fail:
51908 return NULL;
51909 }
51910
51911
51912 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51913 PyObject *resultobj = 0;
51914 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51915 wxSizer *arg2 = (wxSizer *) 0 ;
51916 wxGBSpan result;
51917 void *argp1 = 0 ;
51918 int res1 = 0 ;
51919 void *argp2 = 0 ;
51920 int res2 = 0 ;
51921
51922 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51924 if (!SWIG_IsOK(res1)) {
51925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51926 }
51927 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51928 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51929 if (!SWIG_IsOK(res2)) {
51930 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
51931 }
51932 arg2 = reinterpret_cast< wxSizer * >(argp2);
51933 {
51934 PyThreadState* __tstate = wxPyBeginAllowThreads();
51935 result = (arg1)->GetItemSpan(arg2);
51936 wxPyEndAllowThreads(__tstate);
51937 if (PyErr_Occurred()) SWIG_fail;
51938 }
51939 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51940 return resultobj;
51941 fail:
51942 return NULL;
51943 }
51944
51945
51946 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51947 PyObject *resultobj = 0;
51948 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51949 size_t arg2 ;
51950 wxGBSpan result;
51951 void *argp1 = 0 ;
51952 int res1 = 0 ;
51953 size_t val2 ;
51954 int ecode2 = 0 ;
51955
51956 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51958 if (!SWIG_IsOK(res1)) {
51959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51960 }
51961 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51962 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51963 if (!SWIG_IsOK(ecode2)) {
51964 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
51965 }
51966 arg2 = static_cast< size_t >(val2);
51967 {
51968 PyThreadState* __tstate = wxPyBeginAllowThreads();
51969 result = (arg1)->GetItemSpan(arg2);
51970 wxPyEndAllowThreads(__tstate);
51971 if (PyErr_Occurred()) SWIG_fail;
51972 }
51973 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51974 return resultobj;
51975 fail:
51976 return NULL;
51977 }
51978
51979
51980 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
51981 int argc;
51982 PyObject *argv[3];
51983
51984 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
51985 --argc;
51986 if (argc == 2) {
51987 int _v = 0;
51988 {
51989 void *vptr = 0;
51990 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51991 _v = SWIG_CheckState(res);
51992 }
51993 if (!_v) goto check_1;
51994 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
51995 }
51996 check_1:
51997
51998 if (argc == 2) {
51999 int _v = 0;
52000 {
52001 void *vptr = 0;
52002 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
52003 _v = SWIG_CheckState(res);
52004 }
52005 if (!_v) goto check_2;
52006 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
52007 }
52008 check_2:
52009
52010 if (argc == 2) {
52011 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
52012 }
52013
52014 fail:
52015 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
52016 return NULL;
52017 }
52018
52019
52020 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52021 PyObject *resultobj = 0;
52022 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52023 wxWindow *arg2 = (wxWindow *) 0 ;
52024 wxGBSpan *arg3 = 0 ;
52025 bool result;
52026 void *argp1 = 0 ;
52027 int res1 = 0 ;
52028 void *argp2 = 0 ;
52029 int res2 = 0 ;
52030 wxGBSpan temp3 ;
52031
52032 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52034 if (!SWIG_IsOK(res1)) {
52035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52036 }
52037 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52038 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52039 if (!SWIG_IsOK(res2)) {
52040 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
52041 }
52042 arg2 = reinterpret_cast< wxWindow * >(argp2);
52043 {
52044 arg3 = &temp3;
52045 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
52046 }
52047 {
52048 PyThreadState* __tstate = wxPyBeginAllowThreads();
52049 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
52050 wxPyEndAllowThreads(__tstate);
52051 if (PyErr_Occurred()) SWIG_fail;
52052 }
52053 {
52054 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52055 }
52056 return resultobj;
52057 fail:
52058 return NULL;
52059 }
52060
52061
52062 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52063 PyObject *resultobj = 0;
52064 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52065 wxSizer *arg2 = (wxSizer *) 0 ;
52066 wxGBSpan *arg3 = 0 ;
52067 bool result;
52068 void *argp1 = 0 ;
52069 int res1 = 0 ;
52070 void *argp2 = 0 ;
52071 int res2 = 0 ;
52072 wxGBSpan temp3 ;
52073
52074 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52076 if (!SWIG_IsOK(res1)) {
52077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52078 }
52079 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52080 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52081 if (!SWIG_IsOK(res2)) {
52082 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
52083 }
52084 arg2 = reinterpret_cast< wxSizer * >(argp2);
52085 {
52086 arg3 = &temp3;
52087 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
52088 }
52089 {
52090 PyThreadState* __tstate = wxPyBeginAllowThreads();
52091 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
52092 wxPyEndAllowThreads(__tstate);
52093 if (PyErr_Occurred()) SWIG_fail;
52094 }
52095 {
52096 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52097 }
52098 return resultobj;
52099 fail:
52100 return NULL;
52101 }
52102
52103
52104 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52105 PyObject *resultobj = 0;
52106 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52107 size_t arg2 ;
52108 wxGBSpan *arg3 = 0 ;
52109 bool result;
52110 void *argp1 = 0 ;
52111 int res1 = 0 ;
52112 size_t val2 ;
52113 int ecode2 = 0 ;
52114 wxGBSpan temp3 ;
52115
52116 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52118 if (!SWIG_IsOK(res1)) {
52119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52120 }
52121 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52122 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
52123 if (!SWIG_IsOK(ecode2)) {
52124 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
52125 }
52126 arg2 = static_cast< size_t >(val2);
52127 {
52128 arg3 = &temp3;
52129 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
52130 }
52131 {
52132 PyThreadState* __tstate = wxPyBeginAllowThreads();
52133 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
52134 wxPyEndAllowThreads(__tstate);
52135 if (PyErr_Occurred()) SWIG_fail;
52136 }
52137 {
52138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52139 }
52140 return resultobj;
52141 fail:
52142 return NULL;
52143 }
52144
52145
52146 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
52147 int argc;
52148 PyObject *argv[4];
52149
52150 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
52151 --argc;
52152 if (argc == 3) {
52153 int _v = 0;
52154 {
52155 void *vptr = 0;
52156 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52157 _v = SWIG_CheckState(res);
52158 }
52159 if (!_v) goto check_1;
52160 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
52161 }
52162 check_1:
52163
52164 if (argc == 3) {
52165 int _v = 0;
52166 {
52167 void *vptr = 0;
52168 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
52169 _v = SWIG_CheckState(res);
52170 }
52171 if (!_v) goto check_2;
52172 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
52173 }
52174 check_2:
52175
52176 if (argc == 3) {
52177 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
52178 }
52179
52180 fail:
52181 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
52182 return NULL;
52183 }
52184
52185
52186 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52187 PyObject *resultobj = 0;
52188 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52189 wxWindow *arg2 = (wxWindow *) 0 ;
52190 wxGBSizerItem *result = 0 ;
52191 void *argp1 = 0 ;
52192 int res1 = 0 ;
52193 void *argp2 = 0 ;
52194 int res2 = 0 ;
52195
52196 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52198 if (!SWIG_IsOK(res1)) {
52199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52200 }
52201 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52202 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52203 if (!SWIG_IsOK(res2)) {
52204 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
52205 }
52206 arg2 = reinterpret_cast< wxWindow * >(argp2);
52207 {
52208 PyThreadState* __tstate = wxPyBeginAllowThreads();
52209 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
52210 wxPyEndAllowThreads(__tstate);
52211 if (PyErr_Occurred()) SWIG_fail;
52212 }
52213 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52214 return resultobj;
52215 fail:
52216 return NULL;
52217 }
52218
52219
52220 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52221 PyObject *resultobj = 0;
52222 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52223 wxSizer *arg2 = (wxSizer *) 0 ;
52224 wxGBSizerItem *result = 0 ;
52225 void *argp1 = 0 ;
52226 int res1 = 0 ;
52227 void *argp2 = 0 ;
52228 int res2 = 0 ;
52229
52230 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52232 if (!SWIG_IsOK(res1)) {
52233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52234 }
52235 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52236 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52237 if (!SWIG_IsOK(res2)) {
52238 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
52239 }
52240 arg2 = reinterpret_cast< wxSizer * >(argp2);
52241 {
52242 PyThreadState* __tstate = wxPyBeginAllowThreads();
52243 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
52244 wxPyEndAllowThreads(__tstate);
52245 if (PyErr_Occurred()) SWIG_fail;
52246 }
52247 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52248 return resultobj;
52249 fail:
52250 return NULL;
52251 }
52252
52253
52254 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
52255 int argc;
52256 PyObject *argv[3];
52257
52258 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
52259 --argc;
52260 if (argc == 2) {
52261 int _v = 0;
52262 {
52263 void *vptr = 0;
52264 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52265 _v = SWIG_CheckState(res);
52266 }
52267 if (!_v) goto check_1;
52268 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
52269 }
52270 check_1:
52271
52272 if (argc == 2) {
52273 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
52274 }
52275
52276 fail:
52277 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
52278 return NULL;
52279 }
52280
52281
52282 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52283 PyObject *resultobj = 0;
52284 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52285 wxGBPosition *arg2 = 0 ;
52286 wxGBSizerItem *result = 0 ;
52287 void *argp1 = 0 ;
52288 int res1 = 0 ;
52289 wxGBPosition temp2 ;
52290 PyObject * obj0 = 0 ;
52291 PyObject * obj1 = 0 ;
52292 char * kwnames[] = {
52293 (char *) "self",(char *) "pos", NULL
52294 };
52295
52296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
52297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52298 if (!SWIG_IsOK(res1)) {
52299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52300 }
52301 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52302 {
52303 arg2 = &temp2;
52304 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
52305 }
52306 {
52307 PyThreadState* __tstate = wxPyBeginAllowThreads();
52308 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
52309 wxPyEndAllowThreads(__tstate);
52310 if (PyErr_Occurred()) SWIG_fail;
52311 }
52312 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52313 return resultobj;
52314 fail:
52315 return NULL;
52316 }
52317
52318
52319 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52320 PyObject *resultobj = 0;
52321 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52322 wxPoint *arg2 = 0 ;
52323 wxGBSizerItem *result = 0 ;
52324 void *argp1 = 0 ;
52325 int res1 = 0 ;
52326 wxPoint temp2 ;
52327 PyObject * obj0 = 0 ;
52328 PyObject * obj1 = 0 ;
52329 char * kwnames[] = {
52330 (char *) "self",(char *) "pt", NULL
52331 };
52332
52333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
52334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52335 if (!SWIG_IsOK(res1)) {
52336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52337 }
52338 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52339 {
52340 arg2 = &temp2;
52341 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
52342 }
52343 {
52344 PyThreadState* __tstate = wxPyBeginAllowThreads();
52345 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
52346 wxPyEndAllowThreads(__tstate);
52347 if (PyErr_Occurred()) SWIG_fail;
52348 }
52349 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52350 return resultobj;
52351 fail:
52352 return NULL;
52353 }
52354
52355
52356 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52357 PyObject *resultobj = 0;
52358 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52359 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
52360 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
52361 bool result;
52362 void *argp1 = 0 ;
52363 int res1 = 0 ;
52364 void *argp2 = 0 ;
52365 int res2 = 0 ;
52366 void *argp3 = 0 ;
52367 int res3 = 0 ;
52368 PyObject * obj0 = 0 ;
52369 PyObject * obj1 = 0 ;
52370 PyObject * obj2 = 0 ;
52371 char * kwnames[] = {
52372 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
52373 };
52374
52375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52376 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52377 if (!SWIG_IsOK(res1)) {
52378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52379 }
52380 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52381 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52382 if (!SWIG_IsOK(res2)) {
52383 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
52384 }
52385 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
52386 if (obj2) {
52387 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52388 if (!SWIG_IsOK(res3)) {
52389 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
52390 }
52391 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
52392 }
52393 {
52394 PyThreadState* __tstate = wxPyBeginAllowThreads();
52395 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
52396 wxPyEndAllowThreads(__tstate);
52397 if (PyErr_Occurred()) SWIG_fail;
52398 }
52399 {
52400 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52401 }
52402 return resultobj;
52403 fail:
52404 return NULL;
52405 }
52406
52407
52408 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52409 PyObject *resultobj = 0;
52410 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52411 wxGBPosition *arg2 = 0 ;
52412 wxGBSpan *arg3 = 0 ;
52413 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
52414 bool result;
52415 void *argp1 = 0 ;
52416 int res1 = 0 ;
52417 wxGBPosition temp2 ;
52418 wxGBSpan temp3 ;
52419 void *argp4 = 0 ;
52420 int res4 = 0 ;
52421 PyObject * obj0 = 0 ;
52422 PyObject * obj1 = 0 ;
52423 PyObject * obj2 = 0 ;
52424 PyObject * obj3 = 0 ;
52425 char * kwnames[] = {
52426 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
52427 };
52428
52429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52431 if (!SWIG_IsOK(res1)) {
52432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52433 }
52434 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52435 {
52436 arg2 = &temp2;
52437 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
52438 }
52439 {
52440 arg3 = &temp3;
52441 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
52442 }
52443 if (obj3) {
52444 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52445 if (!SWIG_IsOK(res4)) {
52446 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
52447 }
52448 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
52449 }
52450 {
52451 PyThreadState* __tstate = wxPyBeginAllowThreads();
52452 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
52453 wxPyEndAllowThreads(__tstate);
52454 if (PyErr_Occurred()) SWIG_fail;
52455 }
52456 {
52457 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52458 }
52459 return resultobj;
52460 fail:
52461 return NULL;
52462 }
52463
52464
52465 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52466 PyObject *obj;
52467 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52468 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
52469 return SWIG_Py_Void();
52470 }
52471
52472 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52473 return SWIG_Python_InitShadowInstance(args);
52474 }
52475
52476 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52477 PyObject *resultobj = 0;
52478 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52479 wxRelationship arg2 ;
52480 wxWindow *arg3 = (wxWindow *) 0 ;
52481 wxEdge arg4 ;
52482 int arg5 = (int) 0 ;
52483 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
52484 void *argp1 = 0 ;
52485 int res1 = 0 ;
52486 int val2 ;
52487 int ecode2 = 0 ;
52488 void *argp3 = 0 ;
52489 int res3 = 0 ;
52490 int val4 ;
52491 int ecode4 = 0 ;
52492 int val5 ;
52493 int ecode5 = 0 ;
52494 int val6 ;
52495 int ecode6 = 0 ;
52496 PyObject * obj0 = 0 ;
52497 PyObject * obj1 = 0 ;
52498 PyObject * obj2 = 0 ;
52499 PyObject * obj3 = 0 ;
52500 PyObject * obj4 = 0 ;
52501 PyObject * obj5 = 0 ;
52502 char * kwnames[] = {
52503 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
52504 };
52505
52506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
52507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52508 if (!SWIG_IsOK(res1)) {
52509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52510 }
52511 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52512 ecode2 = SWIG_AsVal_int(obj1, &val2);
52513 if (!SWIG_IsOK(ecode2)) {
52514 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
52515 }
52516 arg2 = static_cast< wxRelationship >(val2);
52517 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52518 if (!SWIG_IsOK(res3)) {
52519 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
52520 }
52521 arg3 = reinterpret_cast< wxWindow * >(argp3);
52522 ecode4 = SWIG_AsVal_int(obj3, &val4);
52523 if (!SWIG_IsOK(ecode4)) {
52524 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
52525 }
52526 arg4 = static_cast< wxEdge >(val4);
52527 if (obj4) {
52528 ecode5 = SWIG_AsVal_int(obj4, &val5);
52529 if (!SWIG_IsOK(ecode5)) {
52530 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
52531 }
52532 arg5 = static_cast< int >(val5);
52533 }
52534 if (obj5) {
52535 ecode6 = SWIG_AsVal_int(obj5, &val6);
52536 if (!SWIG_IsOK(ecode6)) {
52537 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
52538 }
52539 arg6 = static_cast< int >(val6);
52540 }
52541 {
52542 PyThreadState* __tstate = wxPyBeginAllowThreads();
52543 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
52544 wxPyEndAllowThreads(__tstate);
52545 if (PyErr_Occurred()) SWIG_fail;
52546 }
52547 resultobj = SWIG_Py_Void();
52548 return resultobj;
52549 fail:
52550 return NULL;
52551 }
52552
52553
52554 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52555 PyObject *resultobj = 0;
52556 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52557 wxWindow *arg2 = (wxWindow *) 0 ;
52558 int arg3 = (int) 0 ;
52559 void *argp1 = 0 ;
52560 int res1 = 0 ;
52561 void *argp2 = 0 ;
52562 int res2 = 0 ;
52563 int val3 ;
52564 int ecode3 = 0 ;
52565 PyObject * obj0 = 0 ;
52566 PyObject * obj1 = 0 ;
52567 PyObject * obj2 = 0 ;
52568 char * kwnames[] = {
52569 (char *) "self",(char *) "sibling",(char *) "marg", NULL
52570 };
52571
52572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52574 if (!SWIG_IsOK(res1)) {
52575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52576 }
52577 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52578 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52579 if (!SWIG_IsOK(res2)) {
52580 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
52581 }
52582 arg2 = reinterpret_cast< wxWindow * >(argp2);
52583 if (obj2) {
52584 ecode3 = SWIG_AsVal_int(obj2, &val3);
52585 if (!SWIG_IsOK(ecode3)) {
52586 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
52587 }
52588 arg3 = static_cast< int >(val3);
52589 }
52590 {
52591 PyThreadState* __tstate = wxPyBeginAllowThreads();
52592 (arg1)->LeftOf(arg2,arg3);
52593 wxPyEndAllowThreads(__tstate);
52594 if (PyErr_Occurred()) SWIG_fail;
52595 }
52596 resultobj = SWIG_Py_Void();
52597 return resultobj;
52598 fail:
52599 return NULL;
52600 }
52601
52602
52603 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52604 PyObject *resultobj = 0;
52605 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52606 wxWindow *arg2 = (wxWindow *) 0 ;
52607 int arg3 = (int) 0 ;
52608 void *argp1 = 0 ;
52609 int res1 = 0 ;
52610 void *argp2 = 0 ;
52611 int res2 = 0 ;
52612 int val3 ;
52613 int ecode3 = 0 ;
52614 PyObject * obj0 = 0 ;
52615 PyObject * obj1 = 0 ;
52616 PyObject * obj2 = 0 ;
52617 char * kwnames[] = {
52618 (char *) "self",(char *) "sibling",(char *) "marg", NULL
52619 };
52620
52621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52623 if (!SWIG_IsOK(res1)) {
52624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52625 }
52626 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52627 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52628 if (!SWIG_IsOK(res2)) {
52629 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
52630 }
52631 arg2 = reinterpret_cast< wxWindow * >(argp2);
52632 if (obj2) {
52633 ecode3 = SWIG_AsVal_int(obj2, &val3);
52634 if (!SWIG_IsOK(ecode3)) {
52635 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
52636 }
52637 arg3 = static_cast< int >(val3);
52638 }
52639 {
52640 PyThreadState* __tstate = wxPyBeginAllowThreads();
52641 (arg1)->RightOf(arg2,arg3);
52642 wxPyEndAllowThreads(__tstate);
52643 if (PyErr_Occurred()) SWIG_fail;
52644 }
52645 resultobj = SWIG_Py_Void();
52646 return resultobj;
52647 fail:
52648 return NULL;
52649 }
52650
52651
52652 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52653 PyObject *resultobj = 0;
52654 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52655 wxWindow *arg2 = (wxWindow *) 0 ;
52656 int arg3 = (int) 0 ;
52657 void *argp1 = 0 ;
52658 int res1 = 0 ;
52659 void *argp2 = 0 ;
52660 int res2 = 0 ;
52661 int val3 ;
52662 int ecode3 = 0 ;
52663 PyObject * obj0 = 0 ;
52664 PyObject * obj1 = 0 ;
52665 PyObject * obj2 = 0 ;
52666 char * kwnames[] = {
52667 (char *) "self",(char *) "sibling",(char *) "marg", NULL
52668 };
52669
52670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52672 if (!SWIG_IsOK(res1)) {
52673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52674 }
52675 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52676 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52677 if (!SWIG_IsOK(res2)) {
52678 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
52679 }
52680 arg2 = reinterpret_cast< wxWindow * >(argp2);
52681 if (obj2) {
52682 ecode3 = SWIG_AsVal_int(obj2, &val3);
52683 if (!SWIG_IsOK(ecode3)) {
52684 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
52685 }
52686 arg3 = static_cast< int >(val3);
52687 }
52688 {
52689 PyThreadState* __tstate = wxPyBeginAllowThreads();
52690 (arg1)->Above(arg2,arg3);
52691 wxPyEndAllowThreads(__tstate);
52692 if (PyErr_Occurred()) SWIG_fail;
52693 }
52694 resultobj = SWIG_Py_Void();
52695 return resultobj;
52696 fail:
52697 return NULL;
52698 }
52699
52700
52701 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52702 PyObject *resultobj = 0;
52703 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52704 wxWindow *arg2 = (wxWindow *) 0 ;
52705 int arg3 = (int) 0 ;
52706 void *argp1 = 0 ;
52707 int res1 = 0 ;
52708 void *argp2 = 0 ;
52709 int res2 = 0 ;
52710 int val3 ;
52711 int ecode3 = 0 ;
52712 PyObject * obj0 = 0 ;
52713 PyObject * obj1 = 0 ;
52714 PyObject * obj2 = 0 ;
52715 char * kwnames[] = {
52716 (char *) "self",(char *) "sibling",(char *) "marg", NULL
52717 };
52718
52719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52721 if (!SWIG_IsOK(res1)) {
52722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52723 }
52724 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52725 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52726 if (!SWIG_IsOK(res2)) {
52727 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
52728 }
52729 arg2 = reinterpret_cast< wxWindow * >(argp2);
52730 if (obj2) {
52731 ecode3 = SWIG_AsVal_int(obj2, &val3);
52732 if (!SWIG_IsOK(ecode3)) {
52733 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
52734 }
52735 arg3 = static_cast< int >(val3);
52736 }
52737 {
52738 PyThreadState* __tstate = wxPyBeginAllowThreads();
52739 (arg1)->Below(arg2,arg3);
52740 wxPyEndAllowThreads(__tstate);
52741 if (PyErr_Occurred()) SWIG_fail;
52742 }
52743 resultobj = SWIG_Py_Void();
52744 return resultobj;
52745 fail:
52746 return NULL;
52747 }
52748
52749
52750 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52751 PyObject *resultobj = 0;
52752 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52753 wxWindow *arg2 = (wxWindow *) 0 ;
52754 wxEdge arg3 ;
52755 int arg4 = (int) 0 ;
52756 void *argp1 = 0 ;
52757 int res1 = 0 ;
52758 void *argp2 = 0 ;
52759 int res2 = 0 ;
52760 int val3 ;
52761 int ecode3 = 0 ;
52762 int val4 ;
52763 int ecode4 = 0 ;
52764 PyObject * obj0 = 0 ;
52765 PyObject * obj1 = 0 ;
52766 PyObject * obj2 = 0 ;
52767 PyObject * obj3 = 0 ;
52768 char * kwnames[] = {
52769 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
52770 };
52771
52772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52774 if (!SWIG_IsOK(res1)) {
52775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52776 }
52777 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52778 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52779 if (!SWIG_IsOK(res2)) {
52780 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
52781 }
52782 arg2 = reinterpret_cast< wxWindow * >(argp2);
52783 ecode3 = SWIG_AsVal_int(obj2, &val3);
52784 if (!SWIG_IsOK(ecode3)) {
52785 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
52786 }
52787 arg3 = static_cast< wxEdge >(val3);
52788 if (obj3) {
52789 ecode4 = SWIG_AsVal_int(obj3, &val4);
52790 if (!SWIG_IsOK(ecode4)) {
52791 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
52792 }
52793 arg4 = static_cast< int >(val4);
52794 }
52795 {
52796 PyThreadState* __tstate = wxPyBeginAllowThreads();
52797 (arg1)->SameAs(arg2,arg3,arg4);
52798 wxPyEndAllowThreads(__tstate);
52799 if (PyErr_Occurred()) SWIG_fail;
52800 }
52801 resultobj = SWIG_Py_Void();
52802 return resultobj;
52803 fail:
52804 return NULL;
52805 }
52806
52807
52808 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52809 PyObject *resultobj = 0;
52810 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52811 wxWindow *arg2 = (wxWindow *) 0 ;
52812 wxEdge arg3 ;
52813 int arg4 ;
52814 void *argp1 = 0 ;
52815 int res1 = 0 ;
52816 void *argp2 = 0 ;
52817 int res2 = 0 ;
52818 int val3 ;
52819 int ecode3 = 0 ;
52820 int val4 ;
52821 int ecode4 = 0 ;
52822 PyObject * obj0 = 0 ;
52823 PyObject * obj1 = 0 ;
52824 PyObject * obj2 = 0 ;
52825 PyObject * obj3 = 0 ;
52826 char * kwnames[] = {
52827 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
52828 };
52829
52830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52832 if (!SWIG_IsOK(res1)) {
52833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52834 }
52835 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52836 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52837 if (!SWIG_IsOK(res2)) {
52838 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
52839 }
52840 arg2 = reinterpret_cast< wxWindow * >(argp2);
52841 ecode3 = SWIG_AsVal_int(obj2, &val3);
52842 if (!SWIG_IsOK(ecode3)) {
52843 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
52844 }
52845 arg3 = static_cast< wxEdge >(val3);
52846 ecode4 = SWIG_AsVal_int(obj3, &val4);
52847 if (!SWIG_IsOK(ecode4)) {
52848 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
52849 }
52850 arg4 = static_cast< int >(val4);
52851 {
52852 PyThreadState* __tstate = wxPyBeginAllowThreads();
52853 (arg1)->PercentOf(arg2,arg3,arg4);
52854 wxPyEndAllowThreads(__tstate);
52855 if (PyErr_Occurred()) SWIG_fail;
52856 }
52857 resultobj = SWIG_Py_Void();
52858 return resultobj;
52859 fail:
52860 return NULL;
52861 }
52862
52863
52864 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52865 PyObject *resultobj = 0;
52866 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52867 int arg2 ;
52868 void *argp1 = 0 ;
52869 int res1 = 0 ;
52870 int val2 ;
52871 int ecode2 = 0 ;
52872 PyObject * obj0 = 0 ;
52873 PyObject * obj1 = 0 ;
52874 char * kwnames[] = {
52875 (char *) "self",(char *) "val", NULL
52876 };
52877
52878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
52879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52880 if (!SWIG_IsOK(res1)) {
52881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52882 }
52883 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52884 ecode2 = SWIG_AsVal_int(obj1, &val2);
52885 if (!SWIG_IsOK(ecode2)) {
52886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
52887 }
52888 arg2 = static_cast< int >(val2);
52889 {
52890 PyThreadState* __tstate = wxPyBeginAllowThreads();
52891 (arg1)->Absolute(arg2);
52892 wxPyEndAllowThreads(__tstate);
52893 if (PyErr_Occurred()) SWIG_fail;
52894 }
52895 resultobj = SWIG_Py_Void();
52896 return resultobj;
52897 fail:
52898 return NULL;
52899 }
52900
52901
52902 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52903 PyObject *resultobj = 0;
52904 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52905 void *argp1 = 0 ;
52906 int res1 = 0 ;
52907 PyObject *swig_obj[1] ;
52908
52909 if (!args) SWIG_fail;
52910 swig_obj[0] = args;
52911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52912 if (!SWIG_IsOK(res1)) {
52913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52914 }
52915 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52916 {
52917 PyThreadState* __tstate = wxPyBeginAllowThreads();
52918 (arg1)->Unconstrained();
52919 wxPyEndAllowThreads(__tstate);
52920 if (PyErr_Occurred()) SWIG_fail;
52921 }
52922 resultobj = SWIG_Py_Void();
52923 return resultobj;
52924 fail:
52925 return NULL;
52926 }
52927
52928
52929 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52930 PyObject *resultobj = 0;
52931 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52932 void *argp1 = 0 ;
52933 int res1 = 0 ;
52934 PyObject *swig_obj[1] ;
52935
52936 if (!args) SWIG_fail;
52937 swig_obj[0] = args;
52938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52939 if (!SWIG_IsOK(res1)) {
52940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52941 }
52942 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52943 {
52944 PyThreadState* __tstate = wxPyBeginAllowThreads();
52945 (arg1)->AsIs();
52946 wxPyEndAllowThreads(__tstate);
52947 if (PyErr_Occurred()) SWIG_fail;
52948 }
52949 resultobj = SWIG_Py_Void();
52950 return resultobj;
52951 fail:
52952 return NULL;
52953 }
52954
52955
52956 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52957 PyObject *resultobj = 0;
52958 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52959 wxWindow *result = 0 ;
52960 void *argp1 = 0 ;
52961 int res1 = 0 ;
52962 PyObject *swig_obj[1] ;
52963
52964 if (!args) SWIG_fail;
52965 swig_obj[0] = args;
52966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52967 if (!SWIG_IsOK(res1)) {
52968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52969 }
52970 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52971 {
52972 PyThreadState* __tstate = wxPyBeginAllowThreads();
52973 result = (wxWindow *)(arg1)->GetOtherWindow();
52974 wxPyEndAllowThreads(__tstate);
52975 if (PyErr_Occurred()) SWIG_fail;
52976 }
52977 {
52978 resultobj = wxPyMake_wxObject(result, 0);
52979 }
52980 return resultobj;
52981 fail:
52982 return NULL;
52983 }
52984
52985
52986 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52987 PyObject *resultobj = 0;
52988 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52989 wxEdge result;
52990 void *argp1 = 0 ;
52991 int res1 = 0 ;
52992 PyObject *swig_obj[1] ;
52993
52994 if (!args) SWIG_fail;
52995 swig_obj[0] = args;
52996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52997 if (!SWIG_IsOK(res1)) {
52998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52999 }
53000 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53001 {
53002 PyThreadState* __tstate = wxPyBeginAllowThreads();
53003 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
53004 wxPyEndAllowThreads(__tstate);
53005 if (PyErr_Occurred()) SWIG_fail;
53006 }
53007 resultobj = SWIG_From_int(static_cast< int >(result));
53008 return resultobj;
53009 fail:
53010 return NULL;
53011 }
53012
53013
53014 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53015 PyObject *resultobj = 0;
53016 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53017 wxEdge arg2 ;
53018 void *argp1 = 0 ;
53019 int res1 = 0 ;
53020 int val2 ;
53021 int ecode2 = 0 ;
53022 PyObject * obj0 = 0 ;
53023 PyObject * obj1 = 0 ;
53024 char * kwnames[] = {
53025 (char *) "self",(char *) "which", NULL
53026 };
53027
53028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
53029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53030 if (!SWIG_IsOK(res1)) {
53031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53032 }
53033 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53034 ecode2 = SWIG_AsVal_int(obj1, &val2);
53035 if (!SWIG_IsOK(ecode2)) {
53036 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
53037 }
53038 arg2 = static_cast< wxEdge >(val2);
53039 {
53040 PyThreadState* __tstate = wxPyBeginAllowThreads();
53041 (arg1)->SetEdge(arg2);
53042 wxPyEndAllowThreads(__tstate);
53043 if (PyErr_Occurred()) SWIG_fail;
53044 }
53045 resultobj = SWIG_Py_Void();
53046 return resultobj;
53047 fail:
53048 return NULL;
53049 }
53050
53051
53052 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53053 PyObject *resultobj = 0;
53054 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53055 int arg2 ;
53056 void *argp1 = 0 ;
53057 int res1 = 0 ;
53058 int val2 ;
53059 int ecode2 = 0 ;
53060 PyObject * obj0 = 0 ;
53061 PyObject * obj1 = 0 ;
53062 char * kwnames[] = {
53063 (char *) "self",(char *) "v", NULL
53064 };
53065
53066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
53067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53068 if (!SWIG_IsOK(res1)) {
53069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53070 }
53071 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53072 ecode2 = SWIG_AsVal_int(obj1, &val2);
53073 if (!SWIG_IsOK(ecode2)) {
53074 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
53075 }
53076 arg2 = static_cast< int >(val2);
53077 {
53078 PyThreadState* __tstate = wxPyBeginAllowThreads();
53079 (arg1)->SetValue(arg2);
53080 wxPyEndAllowThreads(__tstate);
53081 if (PyErr_Occurred()) SWIG_fail;
53082 }
53083 resultobj = SWIG_Py_Void();
53084 return resultobj;
53085 fail:
53086 return NULL;
53087 }
53088
53089
53090 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53091 PyObject *resultobj = 0;
53092 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53093 int result;
53094 void *argp1 = 0 ;
53095 int res1 = 0 ;
53096 PyObject *swig_obj[1] ;
53097
53098 if (!args) SWIG_fail;
53099 swig_obj[0] = args;
53100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53101 if (!SWIG_IsOK(res1)) {
53102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53103 }
53104 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53105 {
53106 PyThreadState* __tstate = wxPyBeginAllowThreads();
53107 result = (int)(arg1)->GetMargin();
53108 wxPyEndAllowThreads(__tstate);
53109 if (PyErr_Occurred()) SWIG_fail;
53110 }
53111 resultobj = SWIG_From_int(static_cast< int >(result));
53112 return resultobj;
53113 fail:
53114 return NULL;
53115 }
53116
53117
53118 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53119 PyObject *resultobj = 0;
53120 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53121 int arg2 ;
53122 void *argp1 = 0 ;
53123 int res1 = 0 ;
53124 int val2 ;
53125 int ecode2 = 0 ;
53126 PyObject * obj0 = 0 ;
53127 PyObject * obj1 = 0 ;
53128 char * kwnames[] = {
53129 (char *) "self",(char *) "m", NULL
53130 };
53131
53132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
53133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53134 if (!SWIG_IsOK(res1)) {
53135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53136 }
53137 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53138 ecode2 = SWIG_AsVal_int(obj1, &val2);
53139 if (!SWIG_IsOK(ecode2)) {
53140 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
53141 }
53142 arg2 = static_cast< int >(val2);
53143 {
53144 PyThreadState* __tstate = wxPyBeginAllowThreads();
53145 (arg1)->SetMargin(arg2);
53146 wxPyEndAllowThreads(__tstate);
53147 if (PyErr_Occurred()) SWIG_fail;
53148 }
53149 resultobj = SWIG_Py_Void();
53150 return resultobj;
53151 fail:
53152 return NULL;
53153 }
53154
53155
53156 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53157 PyObject *resultobj = 0;
53158 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53159 int result;
53160 void *argp1 = 0 ;
53161 int res1 = 0 ;
53162 PyObject *swig_obj[1] ;
53163
53164 if (!args) SWIG_fail;
53165 swig_obj[0] = args;
53166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53167 if (!SWIG_IsOK(res1)) {
53168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53169 }
53170 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53171 {
53172 PyThreadState* __tstate = wxPyBeginAllowThreads();
53173 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
53174 wxPyEndAllowThreads(__tstate);
53175 if (PyErr_Occurred()) SWIG_fail;
53176 }
53177 resultobj = SWIG_From_int(static_cast< int >(result));
53178 return resultobj;
53179 fail:
53180 return NULL;
53181 }
53182
53183
53184 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53185 PyObject *resultobj = 0;
53186 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53187 int result;
53188 void *argp1 = 0 ;
53189 int res1 = 0 ;
53190 PyObject *swig_obj[1] ;
53191
53192 if (!args) SWIG_fail;
53193 swig_obj[0] = args;
53194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53195 if (!SWIG_IsOK(res1)) {
53196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53197 }
53198 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53199 {
53200 PyThreadState* __tstate = wxPyBeginAllowThreads();
53201 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
53202 wxPyEndAllowThreads(__tstate);
53203 if (PyErr_Occurred()) SWIG_fail;
53204 }
53205 resultobj = SWIG_From_int(static_cast< int >(result));
53206 return resultobj;
53207 fail:
53208 return NULL;
53209 }
53210
53211
53212 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53213 PyObject *resultobj = 0;
53214 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53215 int result;
53216 void *argp1 = 0 ;
53217 int res1 = 0 ;
53218 PyObject *swig_obj[1] ;
53219
53220 if (!args) SWIG_fail;
53221 swig_obj[0] = args;
53222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53223 if (!SWIG_IsOK(res1)) {
53224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53225 }
53226 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53227 {
53228 PyThreadState* __tstate = wxPyBeginAllowThreads();
53229 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
53230 wxPyEndAllowThreads(__tstate);
53231 if (PyErr_Occurred()) SWIG_fail;
53232 }
53233 resultobj = SWIG_From_int(static_cast< int >(result));
53234 return resultobj;
53235 fail:
53236 return NULL;
53237 }
53238
53239
53240 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53241 PyObject *resultobj = 0;
53242 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53243 bool result;
53244 void *argp1 = 0 ;
53245 int res1 = 0 ;
53246 PyObject *swig_obj[1] ;
53247
53248 if (!args) SWIG_fail;
53249 swig_obj[0] = args;
53250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53251 if (!SWIG_IsOK(res1)) {
53252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53253 }
53254 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53255 {
53256 PyThreadState* __tstate = wxPyBeginAllowThreads();
53257 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
53258 wxPyEndAllowThreads(__tstate);
53259 if (PyErr_Occurred()) SWIG_fail;
53260 }
53261 {
53262 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53263 }
53264 return resultobj;
53265 fail:
53266 return NULL;
53267 }
53268
53269
53270 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53271 PyObject *resultobj = 0;
53272 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53273 bool arg2 ;
53274 void *argp1 = 0 ;
53275 int res1 = 0 ;
53276 bool val2 ;
53277 int ecode2 = 0 ;
53278 PyObject * obj0 = 0 ;
53279 PyObject * obj1 = 0 ;
53280 char * kwnames[] = {
53281 (char *) "self",(char *) "d", NULL
53282 };
53283
53284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
53285 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53286 if (!SWIG_IsOK(res1)) {
53287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53288 }
53289 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53290 ecode2 = SWIG_AsVal_bool(obj1, &val2);
53291 if (!SWIG_IsOK(ecode2)) {
53292 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
53293 }
53294 arg2 = static_cast< bool >(val2);
53295 {
53296 PyThreadState* __tstate = wxPyBeginAllowThreads();
53297 (arg1)->SetDone(arg2);
53298 wxPyEndAllowThreads(__tstate);
53299 if (PyErr_Occurred()) SWIG_fail;
53300 }
53301 resultobj = SWIG_Py_Void();
53302 return resultobj;
53303 fail:
53304 return NULL;
53305 }
53306
53307
53308 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53309 PyObject *resultobj = 0;
53310 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53311 wxRelationship result;
53312 void *argp1 = 0 ;
53313 int res1 = 0 ;
53314 PyObject *swig_obj[1] ;
53315
53316 if (!args) SWIG_fail;
53317 swig_obj[0] = args;
53318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53319 if (!SWIG_IsOK(res1)) {
53320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53321 }
53322 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53323 {
53324 PyThreadState* __tstate = wxPyBeginAllowThreads();
53325 result = (wxRelationship)(arg1)->GetRelationship();
53326 wxPyEndAllowThreads(__tstate);
53327 if (PyErr_Occurred()) SWIG_fail;
53328 }
53329 resultobj = SWIG_From_int(static_cast< int >(result));
53330 return resultobj;
53331 fail:
53332 return NULL;
53333 }
53334
53335
53336 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53337 PyObject *resultobj = 0;
53338 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53339 wxRelationship arg2 ;
53340 void *argp1 = 0 ;
53341 int res1 = 0 ;
53342 int val2 ;
53343 int ecode2 = 0 ;
53344 PyObject * obj0 = 0 ;
53345 PyObject * obj1 = 0 ;
53346 char * kwnames[] = {
53347 (char *) "self",(char *) "r", NULL
53348 };
53349
53350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
53351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53352 if (!SWIG_IsOK(res1)) {
53353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53354 }
53355 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53356 ecode2 = SWIG_AsVal_int(obj1, &val2);
53357 if (!SWIG_IsOK(ecode2)) {
53358 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
53359 }
53360 arg2 = static_cast< wxRelationship >(val2);
53361 {
53362 PyThreadState* __tstate = wxPyBeginAllowThreads();
53363 (arg1)->SetRelationship(arg2);
53364 wxPyEndAllowThreads(__tstate);
53365 if (PyErr_Occurred()) SWIG_fail;
53366 }
53367 resultobj = SWIG_Py_Void();
53368 return resultobj;
53369 fail:
53370 return NULL;
53371 }
53372
53373
53374 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53375 PyObject *resultobj = 0;
53376 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53377 wxWindow *arg2 = (wxWindow *) 0 ;
53378 bool result;
53379 void *argp1 = 0 ;
53380 int res1 = 0 ;
53381 void *argp2 = 0 ;
53382 int res2 = 0 ;
53383 PyObject * obj0 = 0 ;
53384 PyObject * obj1 = 0 ;
53385 char * kwnames[] = {
53386 (char *) "self",(char *) "otherW", NULL
53387 };
53388
53389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
53390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53391 if (!SWIG_IsOK(res1)) {
53392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53393 }
53394 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53395 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53396 if (!SWIG_IsOK(res2)) {
53397 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
53398 }
53399 arg2 = reinterpret_cast< wxWindow * >(argp2);
53400 {
53401 PyThreadState* __tstate = wxPyBeginAllowThreads();
53402 result = (bool)(arg1)->ResetIfWin(arg2);
53403 wxPyEndAllowThreads(__tstate);
53404 if (PyErr_Occurred()) SWIG_fail;
53405 }
53406 {
53407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53408 }
53409 return resultobj;
53410 fail:
53411 return NULL;
53412 }
53413
53414
53415 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53416 PyObject *resultobj = 0;
53417 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53418 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
53419 wxWindow *arg3 = (wxWindow *) 0 ;
53420 bool result;
53421 void *argp1 = 0 ;
53422 int res1 = 0 ;
53423 void *argp2 = 0 ;
53424 int res2 = 0 ;
53425 void *argp3 = 0 ;
53426 int res3 = 0 ;
53427 PyObject * obj0 = 0 ;
53428 PyObject * obj1 = 0 ;
53429 PyObject * obj2 = 0 ;
53430 char * kwnames[] = {
53431 (char *) "self",(char *) "constraints",(char *) "win", NULL
53432 };
53433
53434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53436 if (!SWIG_IsOK(res1)) {
53437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53438 }
53439 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53440 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53441 if (!SWIG_IsOK(res2)) {
53442 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
53443 }
53444 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
53445 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
53446 if (!SWIG_IsOK(res3)) {
53447 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
53448 }
53449 arg3 = reinterpret_cast< wxWindow * >(argp3);
53450 {
53451 PyThreadState* __tstate = wxPyBeginAllowThreads();
53452 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
53453 wxPyEndAllowThreads(__tstate);
53454 if (PyErr_Occurred()) SWIG_fail;
53455 }
53456 {
53457 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53458 }
53459 return resultobj;
53460 fail:
53461 return NULL;
53462 }
53463
53464
53465 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53466 PyObject *resultobj = 0;
53467 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53468 wxEdge arg2 ;
53469 wxWindow *arg3 = (wxWindow *) 0 ;
53470 wxWindow *arg4 = (wxWindow *) 0 ;
53471 int result;
53472 void *argp1 = 0 ;
53473 int res1 = 0 ;
53474 int val2 ;
53475 int ecode2 = 0 ;
53476 void *argp3 = 0 ;
53477 int res3 = 0 ;
53478 void *argp4 = 0 ;
53479 int res4 = 0 ;
53480 PyObject * obj0 = 0 ;
53481 PyObject * obj1 = 0 ;
53482 PyObject * obj2 = 0 ;
53483 PyObject * obj3 = 0 ;
53484 char * kwnames[] = {
53485 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
53486 };
53487
53488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53490 if (!SWIG_IsOK(res1)) {
53491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53492 }
53493 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53494 ecode2 = SWIG_AsVal_int(obj1, &val2);
53495 if (!SWIG_IsOK(ecode2)) {
53496 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
53497 }
53498 arg2 = static_cast< wxEdge >(val2);
53499 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
53500 if (!SWIG_IsOK(res3)) {
53501 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
53502 }
53503 arg3 = reinterpret_cast< wxWindow * >(argp3);
53504 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
53505 if (!SWIG_IsOK(res4)) {
53506 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
53507 }
53508 arg4 = reinterpret_cast< wxWindow * >(argp4);
53509 {
53510 PyThreadState* __tstate = wxPyBeginAllowThreads();
53511 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
53512 wxPyEndAllowThreads(__tstate);
53513 if (PyErr_Occurred()) SWIG_fail;
53514 }
53515 resultobj = SWIG_From_int(static_cast< int >(result));
53516 return resultobj;
53517 fail:
53518 return NULL;
53519 }
53520
53521
53522 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53523 PyObject *obj;
53524 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53525 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
53526 return SWIG_Py_Void();
53527 }
53528
53529 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53530 PyObject *resultobj = 0;
53531 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53532 wxIndividualLayoutConstraint *result = 0 ;
53533 void *argp1 = 0 ;
53534 int res1 = 0 ;
53535 PyObject *swig_obj[1] ;
53536
53537 if (!args) SWIG_fail;
53538 swig_obj[0] = args;
53539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53540 if (!SWIG_IsOK(res1)) {
53541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53542 }
53543 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53544 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
53545 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53546 return resultobj;
53547 fail:
53548 return NULL;
53549 }
53550
53551
53552 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53553 PyObject *resultobj = 0;
53554 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53555 wxIndividualLayoutConstraint *result = 0 ;
53556 void *argp1 = 0 ;
53557 int res1 = 0 ;
53558 PyObject *swig_obj[1] ;
53559
53560 if (!args) SWIG_fail;
53561 swig_obj[0] = args;
53562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53563 if (!SWIG_IsOK(res1)) {
53564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53565 }
53566 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53567 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
53568 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53569 return resultobj;
53570 fail:
53571 return NULL;
53572 }
53573
53574
53575 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53576 PyObject *resultobj = 0;
53577 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53578 wxIndividualLayoutConstraint *result = 0 ;
53579 void *argp1 = 0 ;
53580 int res1 = 0 ;
53581 PyObject *swig_obj[1] ;
53582
53583 if (!args) SWIG_fail;
53584 swig_obj[0] = args;
53585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53586 if (!SWIG_IsOK(res1)) {
53587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53588 }
53589 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53590 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
53591 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53592 return resultobj;
53593 fail:
53594 return NULL;
53595 }
53596
53597
53598 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53599 PyObject *resultobj = 0;
53600 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53601 wxIndividualLayoutConstraint *result = 0 ;
53602 void *argp1 = 0 ;
53603 int res1 = 0 ;
53604 PyObject *swig_obj[1] ;
53605
53606 if (!args) SWIG_fail;
53607 swig_obj[0] = args;
53608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53609 if (!SWIG_IsOK(res1)) {
53610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53611 }
53612 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53613 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
53614 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53615 return resultobj;
53616 fail:
53617 return NULL;
53618 }
53619
53620
53621 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53622 PyObject *resultobj = 0;
53623 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53624 wxIndividualLayoutConstraint *result = 0 ;
53625 void *argp1 = 0 ;
53626 int res1 = 0 ;
53627 PyObject *swig_obj[1] ;
53628
53629 if (!args) SWIG_fail;
53630 swig_obj[0] = args;
53631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53632 if (!SWIG_IsOK(res1)) {
53633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53634 }
53635 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53636 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
53637 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53638 return resultobj;
53639 fail:
53640 return NULL;
53641 }
53642
53643
53644 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53645 PyObject *resultobj = 0;
53646 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53647 wxIndividualLayoutConstraint *result = 0 ;
53648 void *argp1 = 0 ;
53649 int res1 = 0 ;
53650 PyObject *swig_obj[1] ;
53651
53652 if (!args) SWIG_fail;
53653 swig_obj[0] = args;
53654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53655 if (!SWIG_IsOK(res1)) {
53656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53657 }
53658 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53659 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
53660 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53661 return resultobj;
53662 fail:
53663 return NULL;
53664 }
53665
53666
53667 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53668 PyObject *resultobj = 0;
53669 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53670 wxIndividualLayoutConstraint *result = 0 ;
53671 void *argp1 = 0 ;
53672 int res1 = 0 ;
53673 PyObject *swig_obj[1] ;
53674
53675 if (!args) SWIG_fail;
53676 swig_obj[0] = args;
53677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53678 if (!SWIG_IsOK(res1)) {
53679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53680 }
53681 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53682 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
53683 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53684 return resultobj;
53685 fail:
53686 return NULL;
53687 }
53688
53689
53690 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53691 PyObject *resultobj = 0;
53692 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53693 wxIndividualLayoutConstraint *result = 0 ;
53694 void *argp1 = 0 ;
53695 int res1 = 0 ;
53696 PyObject *swig_obj[1] ;
53697
53698 if (!args) SWIG_fail;
53699 swig_obj[0] = args;
53700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53701 if (!SWIG_IsOK(res1)) {
53702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53703 }
53704 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53705 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
53706 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53707 return resultobj;
53708 fail:
53709 return NULL;
53710 }
53711
53712
53713 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53714 PyObject *resultobj = 0;
53715 wxLayoutConstraints *result = 0 ;
53716
53717 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
53718 {
53719 PyThreadState* __tstate = wxPyBeginAllowThreads();
53720 result = (wxLayoutConstraints *)new wxLayoutConstraints();
53721 wxPyEndAllowThreads(__tstate);
53722 if (PyErr_Occurred()) SWIG_fail;
53723 }
53724 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
53725 return resultobj;
53726 fail:
53727 return NULL;
53728 }
53729
53730
53731 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53732 PyObject *resultobj = 0;
53733 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53734 void *argp1 = 0 ;
53735 int res1 = 0 ;
53736 PyObject *swig_obj[1] ;
53737
53738 if (!args) SWIG_fail;
53739 swig_obj[0] = args;
53740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
53741 if (!SWIG_IsOK(res1)) {
53742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53743 }
53744 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53745 {
53746 PyThreadState* __tstate = wxPyBeginAllowThreads();
53747 delete arg1;
53748
53749 wxPyEndAllowThreads(__tstate);
53750 if (PyErr_Occurred()) SWIG_fail;
53751 }
53752 resultobj = SWIG_Py_Void();
53753 return resultobj;
53754 fail:
53755 return NULL;
53756 }
53757
53758
53759 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53760 PyObject *resultobj = 0;
53761 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53762 wxWindow *arg2 = (wxWindow *) 0 ;
53763 int *arg3 = (int *) 0 ;
53764 bool result;
53765 void *argp1 = 0 ;
53766 int res1 = 0 ;
53767 void *argp2 = 0 ;
53768 int res2 = 0 ;
53769 int temp3 ;
53770 int res3 = SWIG_TMPOBJ ;
53771 PyObject * obj0 = 0 ;
53772 PyObject * obj1 = 0 ;
53773 char * kwnames[] = {
53774 (char *) "self",(char *) "win", NULL
53775 };
53776
53777 arg3 = &temp3;
53778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
53779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53780 if (!SWIG_IsOK(res1)) {
53781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53782 }
53783 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53784 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53785 if (!SWIG_IsOK(res2)) {
53786 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
53787 }
53788 arg2 = reinterpret_cast< wxWindow * >(argp2);
53789 {
53790 PyThreadState* __tstate = wxPyBeginAllowThreads();
53791 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
53792 wxPyEndAllowThreads(__tstate);
53793 if (PyErr_Occurred()) SWIG_fail;
53794 }
53795 {
53796 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53797 }
53798 if (SWIG_IsTmpObj(res3)) {
53799 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
53800 } else {
53801 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
53802 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
53803 }
53804 return resultobj;
53805 fail:
53806 return NULL;
53807 }
53808
53809
53810 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53811 PyObject *resultobj = 0;
53812 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53813 bool result;
53814 void *argp1 = 0 ;
53815 int res1 = 0 ;
53816 PyObject *swig_obj[1] ;
53817
53818 if (!args) SWIG_fail;
53819 swig_obj[0] = args;
53820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53821 if (!SWIG_IsOK(res1)) {
53822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
53823 }
53824 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53825 {
53826 PyThreadState* __tstate = wxPyBeginAllowThreads();
53827 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
53828 wxPyEndAllowThreads(__tstate);
53829 if (PyErr_Occurred()) SWIG_fail;
53830 }
53831 {
53832 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53833 }
53834 return resultobj;
53835 fail:
53836 return NULL;
53837 }
53838
53839
53840 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53841 PyObject *obj;
53842 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53843 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
53844 return SWIG_Py_Void();
53845 }
53846
53847 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53848 return SWIG_Python_InitShadowInstance(args);
53849 }
53850
53851 static PyMethodDef SwigMethods[] = {
53852 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
53853 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
53854 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
53855 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
53856 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
53857 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
53858 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
53859 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
53860 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
53861 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
53862 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53863 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53864 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53865 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53866 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
53867 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
53868 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
53869 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53870 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53871 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
53872 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
53873 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
53874 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
53875 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
53876 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
53877 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
53878 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
53879 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
53880 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
53881 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
53882 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
53883 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53884 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
53885 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53886 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53887 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53888 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53889 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53890 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
53891 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
53892 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
53893 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
53894 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
53895 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
53896 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
53897 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
53898 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
53899 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53900 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53901 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53902 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53903 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
53904 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
53905 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53906 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
53907 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
53908 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
53909 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
53910 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
53911 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
53912 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
53913 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
53914 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
53915 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
53916 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
53917 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
53918 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
53919 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53920 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
53921 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
53922 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
53923 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53924 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
53925 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53926 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
53927 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
53928 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
53929 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
53930 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
53931 { (char *)"Rect_GetTopRight", (PyCFunction)_wrap_Rect_GetTopRight, METH_O, NULL},
53932 { (char *)"Rect_SetTopRight", (PyCFunction) _wrap_Rect_SetTopRight, METH_VARARGS | METH_KEYWORDS, NULL},
53933 { (char *)"Rect_GetBottomLeft", (PyCFunction)_wrap_Rect_GetBottomLeft, METH_O, NULL},
53934 { (char *)"Rect_SetBottomLeft", (PyCFunction) _wrap_Rect_SetBottomLeft, METH_VARARGS | METH_KEYWORDS, NULL},
53935 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
53936 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
53937 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
53938 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
53939 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
53940 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
53941 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
53942 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
53943 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
53944 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
53945 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
53946 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
53947 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
53948 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
53949 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53950 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
53951 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53952 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53953 { (char *)"Rect_ContainsXY", (PyCFunction) _wrap_Rect_ContainsXY, METH_VARARGS | METH_KEYWORDS, NULL},
53954 { (char *)"Rect_Contains", (PyCFunction) _wrap_Rect_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
53955 { (char *)"Rect_ContainsRect", (PyCFunction) _wrap_Rect_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
53956 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
53957 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
53958 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
53959 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
53960 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
53961 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
53962 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
53963 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
53964 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
53965 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
53966 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53967 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
53968 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
53969 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
53970 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
53971 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
53972 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
53973 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53974 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
53975 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
53976 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
53977 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
53978 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
53979 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
53980 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
53981 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
53982 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
53983 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
53984 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
53985 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
53986 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
53987 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
53988 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
53989 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53990 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53991 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
53992 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
53993 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
53994 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
53995 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53996 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
53997 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
53998 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
53999 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
54000 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
54001 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
54002 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
54003 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
54004 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
54005 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
54006 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
54007 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
54008 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
54009 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
54010 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
54011 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
54012 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
54013 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
54014 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
54015 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
54016 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
54017 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
54018 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
54019 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
54020 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
54021 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
54022 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
54023 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
54024 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
54025 { (char *)"FSFile_DetachStream", (PyCFunction)_wrap_FSFile_DetachStream, METH_O, NULL},
54026 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
54027 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
54028 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
54029 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
54030 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
54031 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
54032 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
54033 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
54034 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
54035 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54036 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
54037 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54038 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
54039 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
54040 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
54041 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
54042 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
54043 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
54044 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
54045 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
54046 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
54047 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
54048 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
54049 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
54050 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
54051 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54052 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
54053 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
54054 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54055 { (char *)"FileSystem_RemoveHandler", (PyCFunction) _wrap_FileSystem_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54056 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
54057 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
54058 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
54059 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
54060 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
54061 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
54062 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
54063 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54064 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
54065 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
54066 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
54067 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
54068 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54069 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
54070 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
54071 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
54072 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
54073 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
54074 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54075 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
54076 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
54077 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
54078 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
54079 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
54080 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
54081 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
54082 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
54083 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
54084 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
54085 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
54086 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
54087 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
54088 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
54089 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
54090 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
54091 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
54092 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
54093 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
54094 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
54095 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
54096 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
54097 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
54098 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
54099 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
54100 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
54101 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
54102 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
54103 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
54104 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
54105 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
54106 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
54107 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
54108 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
54109 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
54110 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
54111 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
54112 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
54113 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
54114 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
54115 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
54116 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
54117 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
54118 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
54119 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
54120 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
54121 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
54122 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
54123 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
54124 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
54125 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
54126 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
54127 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
54128 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
54129 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
54130 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
54131 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54132 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
54133 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54134 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54135 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
54136 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
54137 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
54138 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
54139 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
54140 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
54141 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
54142 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
54143 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
54144 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
54145 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54146 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54147 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
54148 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
54149 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
54150 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
54151 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
54152 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54153 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
54154 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
54155 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
54156 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
54157 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
54158 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
54159 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
54160 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
54161 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
54162 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
54163 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
54164 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
54165 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
54166 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
54167 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
54168 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
54169 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
54170 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
54171 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
54172 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
54173 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
54174 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54175 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
54176 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
54177 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
54178 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54179 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
54180 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
54181 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
54182 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
54183 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
54184 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
54185 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
54186 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
54187 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
54188 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
54189 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
54190 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
54191 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
54192 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
54193 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
54194 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
54195 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
54196 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
54197 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
54198 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
54199 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54200 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54201 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54202 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
54203 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
54204 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54205 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54206 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
54207 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
54208 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
54209 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
54210 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
54211 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54212 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
54213 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
54214 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
54215 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
54216 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
54217 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
54218 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
54219 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
54220 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
54221 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
54222 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
54223 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
54224 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
54225 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
54226 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
54227 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
54228 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
54229 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
54230 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
54231 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
54232 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
54233 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
54234 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
54235 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
54236 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
54237 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
54238 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
54239 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
54240 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
54241 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
54242 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
54243 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
54244 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
54245 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
54246 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
54247 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
54248 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
54249 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
54250 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54251 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54252 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
54253 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54254 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54255 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54256 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
54257 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
54258 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
54259 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54260 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
54261 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
54262 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
54263 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
54264 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
54265 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
54266 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
54267 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
54268 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
54269 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
54270 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
54271 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
54272 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
54273 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
54274 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
54275 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
54276 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
54277 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
54278 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
54279 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
54280 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
54281 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
54282 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
54283 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
54284 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
54285 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
54286 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
54287 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
54288 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54289 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
54290 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
54291 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
54292 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
54293 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
54294 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
54295 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
54296 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
54297 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
54298 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
54299 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54300 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
54301 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
54302 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
54303 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54304 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
54305 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
54306 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
54307 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
54308 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
54309 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54310 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
54311 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
54312 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54313 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54314 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
54315 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
54316 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54317 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
54318 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
54319 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54320 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54321 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
54322 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
54323 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54324 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
54325 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
54326 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
54327 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
54328 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
54329 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
54330 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
54331 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
54332 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
54333 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
54334 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
54335 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
54336 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
54337 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
54338 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
54339 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
54340 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
54341 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
54342 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
54343 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
54344 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
54345 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
54346 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
54347 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
54348 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
54349 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
54350 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
54351 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
54352 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
54353 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
54354 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54355 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
54356 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
54357 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
54358 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
54359 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
54360 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
54361 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
54362 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
54363 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
54364 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
54365 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
54366 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
54367 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
54368 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
54369 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
54370 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
54371 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
54372 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
54373 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
54374 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
54375 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
54376 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
54377 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
54378 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
54379 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
54380 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
54381 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
54382 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
54383 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
54384 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
54385 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
54386 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
54387 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54388 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
54389 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
54390 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
54391 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
54392 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
54393 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
54394 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
54395 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54396 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
54397 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
54398 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
54399 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
54400 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
54401 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
54402 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
54403 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
54404 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
54405 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
54406 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
54407 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
54408 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
54409 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
54410 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
54411 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
54412 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
54413 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
54414 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
54415 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
54416 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
54417 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
54418 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
54419 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
54420 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
54421 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
54422 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
54423 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
54424 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
54425 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
54426 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
54427 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
54428 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
54429 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
54430 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
54431 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
54432 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
54433 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
54434 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54435 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
54436 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
54437 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
54438 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
54439 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
54440 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
54441 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
54442 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
54443 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
54444 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
54445 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54446 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
54447 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
54448 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
54449 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54450 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
54451 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
54452 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54453 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
54454 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
54455 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54456 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
54457 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
54458 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54459 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
54460 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
54461 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
54462 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54463 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
54464 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54465 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
54466 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
54467 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54468 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
54469 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
54470 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
54471 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54472 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
54473 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
54474 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
54475 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54476 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
54477 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
54478 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54479 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
54480 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
54481 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
54482 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
54483 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
54484 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54485 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
54486 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
54487 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
54488 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
54489 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
54490 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
54491 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
54492 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
54493 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54494 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
54495 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
54496 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
54497 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
54498 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54499 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
54500 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
54501 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
54502 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54503 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
54504 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
54505 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
54506 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
54507 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
54508 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
54509 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54510 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
54511 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
54512 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
54513 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
54514 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
54515 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
54516 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
54517 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
54518 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54519 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54520 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54521 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
54522 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
54523 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
54524 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
54525 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
54526 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
54527 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
54528 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
54529 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
54530 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
54531 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
54532 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
54533 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54534 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
54535 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
54536 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
54537 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54538 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
54539 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
54540 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
54541 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
54542 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
54543 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54544 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54545 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
54546 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
54547 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
54548 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54549 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
54550 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
54551 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
54552 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
54553 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
54554 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
54555 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54556 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
54557 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
54558 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
54559 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
54560 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
54561 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
54562 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
54563 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
54564 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
54565 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54566 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
54567 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
54568 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
54569 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54570 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
54571 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
54572 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
54573 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54574 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
54575 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54576 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
54577 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
54578 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
54579 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
54580 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
54581 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
54582 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
54583 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
54584 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
54585 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
54586 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54587 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
54588 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
54589 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54590 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
54591 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
54592 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
54593 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
54594 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
54595 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54596 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
54597 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
54598 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
54599 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
54600 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
54601 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54602 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
54603 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
54604 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
54605 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
54606 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
54607 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
54608 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54609 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
54610 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
54611 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
54612 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
54613 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
54614 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
54615 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
54616 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
54617 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
54618 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
54619 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
54620 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
54621 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
54622 { (char *)"PyApp_GetLayoutDirection", (PyCFunction)_wrap_PyApp_GetLayoutDirection, METH_O, NULL},
54623 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
54624 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
54625 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
54626 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
54627 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
54628 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
54629 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54630 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
54631 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
54632 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
54633 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
54634 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
54635 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
54636 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
54637 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
54638 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
54639 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
54640 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
54641 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
54642 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
54643 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
54644 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
54645 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
54646 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
54647 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
54648 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
54649 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
54650 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
54651 { (char *)"PyApp_IsDisplayAvailable", (PyCFunction)_wrap_PyApp_IsDisplayAvailable, METH_NOARGS, NULL},
54652 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
54653 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
54654 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
54655 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
54656 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
54657 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
54658 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
54659 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54660 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
54661 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
54662 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
54663 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
54664 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
54665 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
54666 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
54667 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
54668 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
54669 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
54670 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
54671 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
54672 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
54673 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
54674 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
54675 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
54676 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
54677 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
54678 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
54679 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
54680 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
54681 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54682 { (char *)"AcceleratorEntry_Create", (PyCFunction) _wrap_AcceleratorEntry_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54683 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
54684 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
54685 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
54686 { (char *)"AcceleratorEntry_IsOk", (PyCFunction)_wrap_AcceleratorEntry_IsOk, METH_O, NULL},
54687 { (char *)"AcceleratorEntry_ToString", (PyCFunction)_wrap_AcceleratorEntry_ToString, METH_O, NULL},
54688 { (char *)"AcceleratorEntry_FromString", (PyCFunction) _wrap_AcceleratorEntry_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
54689 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
54690 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
54691 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
54692 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
54693 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
54694 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
54695 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
54696 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
54697 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
54698 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
54699 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
54700 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
54701 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
54702 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
54703 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
54704 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
54705 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
54706 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
54707 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
54708 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
54709 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54710 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
54711 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
54712 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
54713 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
54714 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54715 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
54716 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
54717 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
54718 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
54719 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
54720 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
54721 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
54722 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
54723 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
54724 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
54725 { (char *)"Window_GetLayoutDirection", (PyCFunction)_wrap_Window_GetLayoutDirection, METH_O, NULL},
54726 { (char *)"Window_SetLayoutDirection", (PyCFunction) _wrap_Window_SetLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54727 { (char *)"Window_AdjustForLayoutDirection", (PyCFunction) _wrap_Window_AdjustForLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54728 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
54729 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
54730 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
54731 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
54732 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
54733 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
54734 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
54735 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
54736 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
54737 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
54738 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
54739 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
54740 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
54741 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
54742 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
54743 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
54744 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
54745 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
54746 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
54747 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
54748 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
54749 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
54750 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
54751 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
54752 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
54753 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
54754 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
54755 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
54756 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
54757 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
54758 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
54759 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
54760 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
54761 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
54762 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54763 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
54764 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54765 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
54766 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
54767 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
54768 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54769 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
54770 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
54771 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
54772 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
54773 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
54774 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
54775 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
54776 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
54777 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
54778 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
54779 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54780 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
54781 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54782 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
54783 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
54784 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
54785 { (char *)"Window_IsShownOnScreen", (PyCFunction)_wrap_Window_IsShownOnScreen, METH_O, NULL},
54786 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
54787 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
54788 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
54789 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
54790 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
54791 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
54792 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
54793 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54794 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
54795 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
54796 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
54797 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
54798 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
54799 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
54800 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
54801 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
54802 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
54803 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
54804 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
54805 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
54806 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
54807 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
54808 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
54809 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
54810 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
54811 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
54812 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
54813 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
54814 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54815 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54816 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54817 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54818 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
54819 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
54820 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
54821 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
54822 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
54823 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
54824 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
54825 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
54826 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
54827 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
54828 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
54829 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
54830 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
54831 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
54832 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
54833 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
54834 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
54835 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
54836 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
54837 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
54838 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
54839 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
54840 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
54841 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
54842 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
54843 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
54844 { (char *)"Window_IsFrozen", (PyCFunction)_wrap_Window_IsFrozen, METH_O, NULL},
54845 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
54846 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
54847 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
54848 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
54849 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
54850 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54851 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
54852 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
54853 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
54854 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54855 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54856 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54857 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54858 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
54859 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
54860 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
54861 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
54862 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
54863 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
54864 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
54865 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
54866 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
54867 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
54868 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
54869 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
54870 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
54871 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
54872 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
54873 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
54874 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
54875 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
54876 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
54877 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
54878 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
54879 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
54880 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
54881 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
54882 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
54883 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
54884 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
54885 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54886 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
54887 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
54888 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
54889 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
54890 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
54891 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
54892 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
54893 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
54894 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
54895 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
54896 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54897 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
54898 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
54899 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
54900 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
54901 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
54902 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
54903 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
54904 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
54905 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54906 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
54907 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
54908 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
54909 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
54910 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
54911 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
54912 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
54913 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
54914 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
54915 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
54916 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
54917 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
54918 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54919 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
54920 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
54921 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54922 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
54923 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
54924 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
54925 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
54926 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
54927 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
54928 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
54929 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
54930 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
54931 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54932 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
54933 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
54934 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
54935 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
54936 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
54937 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
54938 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
54939 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
54940 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54941 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
54942 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
54943 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
54944 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
54945 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
54946 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54947 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
54948 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
54949 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
54950 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54951 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
54952 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54953 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54954 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54955 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54956 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
54957 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
54958 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
54959 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
54960 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54961 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
54962 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54963 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54964 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54965 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
54966 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
54967 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54968 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54969 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54970 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54971 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
54972 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
54973 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
54974 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
54975 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
54976 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
54977 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
54978 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
54979 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
54980 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
54981 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54982 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54983 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54984 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54985 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
54986 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54987 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54988 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54989 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54990 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
54991 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
54992 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54993 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
54994 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54995 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
54996 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
54997 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
54998 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
54999 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
55000 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
55001 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
55002 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
55003 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
55004 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
55005 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
55006 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
55007 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
55008 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
55009 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
55010 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55011 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
55012 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
55013 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
55014 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
55015 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
55016 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
55017 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
55018 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
55019 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55020 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
55021 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
55022 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
55023 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
55024 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55025 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
55026 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
55027 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
55028 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
55029 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
55030 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
55031 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
55032 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
55033 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55034 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
55035 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
55036 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
55037 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
55038 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
55039 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
55040 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55041 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
55042 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
55043 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
55044 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
55045 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
55046 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
55047 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
55048 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
55049 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
55050 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
55051 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
55052 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
55053 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
55054 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
55055 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
55056 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
55057 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
55058 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
55059 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
55060 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
55061 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
55062 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
55063 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
55064 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
55065 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
55066 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
55067 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
55068 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
55069 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
55070 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
55071 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
55072 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
55073 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
55074 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
55075 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
55076 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
55077 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
55078 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
55079 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
55080 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
55081 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
55082 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
55083 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
55084 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
55085 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
55086 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
55087 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
55088 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
55089 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
55090 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
55091 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
55092 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
55093 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
55094 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
55095 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
55096 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
55097 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
55098 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
55099 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
55100 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
55101 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
55102 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
55103 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
55104 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
55105 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
55106 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
55107 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
55108 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
55109 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
55110 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
55111 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
55112 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
55113 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
55114 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
55115 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55116 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
55117 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55118 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
55119 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
55120 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
55121 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
55122 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
55123 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
55124 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
55125 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
55126 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
55127 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
55128 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
55129 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
55130 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
55131 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
55132 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
55133 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
55134 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
55135 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
55136 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
55137 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
55138 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
55139 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
55140 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
55141 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55142 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
55143 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55144 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
55145 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
55146 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
55147 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
55148 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
55149 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
55150 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
55151 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
55152 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
55153 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
55154 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
55155 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
55156 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
55157 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
55158 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
55159 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
55160 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
55161 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
55162 { (char *)"Sizer__ReplaceWin", (PyCFunction) _wrap_Sizer__ReplaceWin, METH_VARARGS | METH_KEYWORDS, NULL},
55163 { (char *)"Sizer__ReplaceSizer", (PyCFunction) _wrap_Sizer__ReplaceSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55164 { (char *)"Sizer__ReplaceItem", (PyCFunction) _wrap_Sizer__ReplaceItem, METH_VARARGS | METH_KEYWORDS, NULL},
55165 { (char *)"Sizer_SetContainingWindow", (PyCFunction) _wrap_Sizer_SetContainingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55166 { (char *)"Sizer_GetContainingWindow", (PyCFunction)_wrap_Sizer_GetContainingWindow, METH_O, NULL},
55167 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
55168 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
55169 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
55170 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
55171 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
55172 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
55173 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
55174 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
55175 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
55176 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
55177 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
55178 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
55179 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
55180 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55181 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55182 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
55183 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
55184 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
55185 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
55186 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
55187 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
55188 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
55189 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
55190 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
55191 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
55192 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
55193 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55194 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
55195 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
55196 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
55197 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
55198 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55199 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
55200 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
55201 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
55202 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55203 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
55204 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
55205 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
55206 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
55207 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
55208 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
55209 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
55210 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
55211 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
55212 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
55213 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55214 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
55215 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
55216 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
55217 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
55218 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
55219 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
55220 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
55221 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
55222 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
55223 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
55224 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
55225 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
55226 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
55227 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
55228 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
55229 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
55230 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
55231 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
55232 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
55233 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
55234 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
55235 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
55236 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
55237 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
55238 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
55239 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55240 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
55241 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
55242 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
55243 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
55244 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
55245 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
55246 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
55247 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55248 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
55249 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
55250 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
55251 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
55252 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
55253 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
55254 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
55255 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
55256 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
55257 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
55258 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
55259 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55260 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
55261 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
55262 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
55263 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
55264 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
55265 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55266 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55267 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
55268 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
55269 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
55270 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
55271 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
55272 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
55273 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
55274 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
55275 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
55276 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55277 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
55278 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
55279 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55280 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
55281 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
55282 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
55283 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
55284 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
55285 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
55286 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
55287 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
55288 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
55289 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
55290 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55291 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
55292 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
55293 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
55294 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
55295 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
55296 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55297 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
55298 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
55299 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
55300 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
55301 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
55302 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
55303 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
55304 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
55305 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
55306 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
55307 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
55308 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
55309 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
55310 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
55311 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
55312 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
55313 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
55314 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
55315 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
55316 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
55317 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
55318 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
55319 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
55320 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
55321 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
55322 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
55323 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
55324 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
55325 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
55326 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
55327 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
55328 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
55329 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
55330 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
55331 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
55332 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
55333 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
55334 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
55335 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
55336 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
55337 { NULL, NULL, 0, NULL }
55338 };
55339
55340
55341 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
55342
55343 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
55344 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
55345 }
55346 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
55347 return (void *)((wxSizer *) ((wxBoxSizer *) x));
55348 }
55349 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
55350 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
55351 }
55352 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
55353 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
55354 }
55355 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
55356 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
55357 }
55358 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
55359 return (void *)((wxSizer *) ((wxGridSizer *) x));
55360 }
55361 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
55362 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
55363 }
55364 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
55365 return (void *)((wxSizer *) ((wxPySizer *) x));
55366 }
55367 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
55368 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
55369 }
55370 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
55371 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
55372 }
55373 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
55374 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
55375 }
55376 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
55377 return (void *)((wxEvent *) ((wxMenuEvent *) x));
55378 }
55379 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
55380 return (void *)((wxEvent *) ((wxCloseEvent *) x));
55381 }
55382 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
55383 return (void *)((wxEvent *) ((wxMouseEvent *) x));
55384 }
55385 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
55386 return (void *)((wxEvent *) ((wxEraseEvent *) x));
55387 }
55388 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
55389 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
55390 }
55391 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
55392 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
55393 }
55394 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
55395 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
55396 }
55397 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
55398 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
55399 }
55400 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
55401 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
55402 }
55403 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
55404 return (void *)((wxEvent *) ((wxPyEvent *) x));
55405 }
55406 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
55407 return (void *)((wxEvent *) ((wxIdleEvent *) x));
55408 }
55409 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
55410 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
55411 }
55412 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
55413 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
55414 }
55415 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
55416 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
55417 }
55418 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
55419 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
55420 }
55421 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
55422 return (void *)((wxEvent *) ((wxActivateEvent *) x));
55423 }
55424 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
55425 return (void *)((wxEvent *) ((wxSizeEvent *) x));
55426 }
55427 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
55428 return (void *)((wxEvent *) ((wxMoveEvent *) x));
55429 }
55430 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
55431 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
55432 }
55433 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
55434 return (void *)((wxEvent *) ((wxPaintEvent *) x));
55435 }
55436 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
55437 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
55438 }
55439 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
55440 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
55441 }
55442 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
55443 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
55444 }
55445 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
55446 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
55447 }
55448 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
55449 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
55450 }
55451 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
55452 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
55453 }
55454 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
55455 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
55456 }
55457 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
55458 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
55459 }
55460 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
55461 return (void *)((wxEvent *) ((wxFocusEvent *) x));
55462 }
55463 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
55464 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
55465 }
55466 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
55467 return (void *)((wxEvent *) ((wxShowEvent *) x));
55468 }
55469 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
55470 return (void *)((wxEvent *) ((wxCommandEvent *) x));
55471 }
55472 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
55473 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
55474 }
55475 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
55476 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
55477 }
55478 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
55479 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
55480 }
55481 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
55482 return (void *)((wxEvent *) ((wxKeyEvent *) x));
55483 }
55484 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
55485 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
55486 }
55487 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
55488 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
55489 }
55490 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
55491 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
55492 }
55493 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
55494 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
55495 }
55496 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
55497 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
55498 }
55499 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
55500 return (void *)((wxControl *) ((wxControlWithItems *) x));
55501 }
55502 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
55503 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
55504 }
55505 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
55506 return (void *)((wxEvtHandler *) ((wxWindow *) x));
55507 }
55508 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
55509 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
55510 }
55511 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
55512 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
55513 }
55514 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
55515 return (void *)((wxEvtHandler *) ((wxValidator *) x));
55516 }
55517 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
55518 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
55519 }
55520 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
55521 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
55522 }
55523 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
55524 return (void *)((wxEvtHandler *) ((wxMenu *) x));
55525 }
55526 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
55527 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
55528 }
55529 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
55530 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
55531 }
55532 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
55533 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
55534 }
55535 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
55536 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
55537 }
55538 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
55539 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
55540 }
55541 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
55542 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
55543 }
55544 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
55545 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
55546 }
55547 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
55548 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
55549 }
55550 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
55551 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
55552 }
55553 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
55554 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
55555 }
55556 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
55557 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
55558 }
55559 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
55560 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
55561 }
55562 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
55563 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
55564 }
55565 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
55566 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
55567 }
55568 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
55569 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
55570 }
55571 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
55572 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
55573 }
55574 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
55575 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
55576 }
55577 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
55578 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
55579 }
55580 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
55581 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
55582 }
55583 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
55584 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
55585 }
55586 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
55587 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
55588 }
55589 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
55590 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
55591 }
55592 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
55593 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
55594 }
55595 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
55596 return (void *)((wxObject *) ((wxSizerItem *) x));
55597 }
55598 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
55599 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
55600 }
55601 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
55602 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
55603 }
55604 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
55605 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
55606 }
55607 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
55608 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
55609 }
55610 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
55611 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
55612 }
55613 static void *_p_wxSizerTo_p_wxObject(void *x) {
55614 return (void *)((wxObject *) ((wxSizer *) x));
55615 }
55616 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
55617 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
55618 }
55619 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
55620 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
55621 }
55622 static void *_p_wxEventTo_p_wxObject(void *x) {
55623 return (void *)((wxObject *) ((wxEvent *) x));
55624 }
55625 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
55626 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
55627 }
55628 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
55629 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
55630 }
55631 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
55632 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
55633 }
55634 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
55635 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
55636 }
55637 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
55638 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
55639 }
55640 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
55641 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
55642 }
55643 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
55644 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
55645 }
55646 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
55647 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
55648 }
55649 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
55650 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
55651 }
55652 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
55653 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
55654 }
55655 static void *_p_wxControlTo_p_wxObject(void *x) {
55656 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
55657 }
55658 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
55659 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
55660 }
55661 static void *_p_wxFSFileTo_p_wxObject(void *x) {
55662 return (void *)((wxObject *) ((wxFSFile *) x));
55663 }
55664 static void *_p_wxPySizerTo_p_wxObject(void *x) {
55665 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
55666 }
55667 static void *_p_wxPyEventTo_p_wxObject(void *x) {
55668 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
55669 }
55670 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
55671 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
55672 }
55673 static void *_p_wxShowEventTo_p_wxObject(void *x) {
55674 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
55675 }
55676 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
55677 return (void *)((wxObject *) ((wxMenuItem *) x));
55678 }
55679 static void *_p_wxDateEventTo_p_wxObject(void *x) {
55680 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
55681 }
55682 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
55683 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
55684 }
55685 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
55686 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
55687 }
55688 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
55689 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
55690 }
55691 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
55692 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
55693 }
55694 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
55695 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
55696 }
55697 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
55698 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
55699 }
55700 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
55701 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
55702 }
55703 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
55704 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
55705 }
55706 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
55707 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
55708 }
55709 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
55710 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
55711 }
55712 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
55713 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
55714 }
55715 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
55716 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
55717 }
55718 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
55719 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
55720 }
55721 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
55722 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
55723 }
55724 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
55725 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
55726 }
55727 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
55728 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
55729 }
55730 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
55731 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
55732 }
55733 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
55734 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
55735 }
55736 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
55737 return (void *)((wxObject *) ((wxImageHandler *) x));
55738 }
55739 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
55740 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
55741 }
55742 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
55743 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
55744 }
55745 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
55746 return (void *)((wxObject *) ((wxEvtHandler *) x));
55747 }
55748 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
55749 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
55750 }
55751 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
55752 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
55753 }
55754 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
55755 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
55756 }
55757 static void *_p_wxImageTo_p_wxObject(void *x) {
55758 return (void *)((wxObject *) ((wxImage *) x));
55759 }
55760 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
55761 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
55762 }
55763 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
55764 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
55765 }
55766 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
55767 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
55768 }
55769 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
55770 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
55771 }
55772 static void *_p_wxWindowTo_p_wxObject(void *x) {
55773 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
55774 }
55775 static void *_p_wxMenuTo_p_wxObject(void *x) {
55776 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
55777 }
55778 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
55779 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
55780 }
55781 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
55782 return (void *)((wxObject *) ((wxFileSystem *) x));
55783 }
55784 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
55785 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
55786 }
55787 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
55788 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
55789 }
55790 static void *_p_wxPyAppTo_p_wxObject(void *x) {
55791 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
55792 }
55793 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
55794 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
55795 }
55796 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
55797 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
55798 }
55799 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
55800 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
55801 }
55802 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
55803 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
55804 }
55805 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
55806 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
55807 }
55808 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
55809 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
55810 }
55811 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
55812 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
55813 }
55814 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
55815 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
55816 }
55817 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
55818 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
55819 }
55820 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
55821 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
55822 }
55823 static void *_p_wxValidatorTo_p_wxObject(void *x) {
55824 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
55825 }
55826 static void *_p_wxControlTo_p_wxWindow(void *x) {
55827 return (void *)((wxWindow *) ((wxControl *) x));
55828 }
55829 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
55830 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
55831 }
55832 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
55833 return (void *)((wxWindow *) ((wxMenuBar *) x));
55834 }
55835 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
55836 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
55837 }
55838 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
55839 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
55840 }
55841 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
55842 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
55843 }
55844 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
55845 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
55846 }
55847 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
55848 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
55849 }
55850 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
55851 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
55852 }
55853 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
55854 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
55855 }
55856 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
55857 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
55858 }
55859 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
55860 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
55861 }
55862 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
55863 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
55864 }
55865 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
55866 return (void *)((wxValidator *) ((wxPyValidator *) x));
55867 }
55868 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
55869 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
55870 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};
55871 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
55872 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
55873 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
55874 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
55875 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
55876 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
55877 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
55878 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
55879 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
55880 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
55881 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
55882 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
55883 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
55884 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
55885 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
55886 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
55887 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
55888 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
55889 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
55890 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
55891 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
55892 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
55893 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
55894 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
55895 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
55896 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
55897 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
55898 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
55899 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
55900 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
55901 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
55902 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
55903 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
55904 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
55905 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
55906 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
55907 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
55908 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
55909 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
55910 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
55911 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
55912 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
55913 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
55914 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
55915 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
55916 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
55917 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
55918 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
55919 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
55920 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
55921 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
55922 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
55923 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
55924 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
55925 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
55926 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
55927 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
55928 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
55929 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
55930 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
55931 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
55932 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
55933 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
55934 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
55935 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
55936 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
55937 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
55938 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
55939 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
55940 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
55941 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
55942 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
55943 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
55944 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
55945 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
55946 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
55947 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
55948 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
55949 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
55950 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
55951 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
55952 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
55953 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
55954 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
55955 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
55956 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
55957 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
55958 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
55959 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
55960 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
55961 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
55962 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
55963 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
55964 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
55965 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
55966 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
55967 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
55968 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
55969 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
55970 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
55971 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
55972 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
55973 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
55974 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
55975 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
55976 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
55977 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
55978 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
55979 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
55980 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
55981 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
55982 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
55983 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
55984 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
55985 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
55986 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
55987 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
55988 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
55989 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
55990 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
55991 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
55992 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
55993 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
55994 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
55995 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
55996 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
55997 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
55998 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
55999 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
56000
56001 static swig_type_info *swig_type_initial[] = {
56002 &_swigt__p_buffer,
56003 &_swigt__p_char,
56004 &_swigt__p_form_ops_t,
56005 &_swigt__p_int,
56006 &_swigt__p_long,
56007 &_swigt__p_unsigned_char,
56008 &_swigt__p_unsigned_int,
56009 &_swigt__p_unsigned_long,
56010 &_swigt__p_wxANIHandler,
56011 &_swigt__p_wxAcceleratorEntry,
56012 &_swigt__p_wxAcceleratorTable,
56013 &_swigt__p_wxActivateEvent,
56014 &_swigt__p_wxAppTraits,
56015 &_swigt__p_wxArrayString,
56016 &_swigt__p_wxBMPHandler,
56017 &_swigt__p_wxBitmap,
56018 &_swigt__p_wxBoxSizer,
56019 &_swigt__p_wxButton,
56020 &_swigt__p_wxCURHandler,
56021 &_swigt__p_wxCaret,
56022 &_swigt__p_wxChildFocusEvent,
56023 &_swigt__p_wxClipboardTextEvent,
56024 &_swigt__p_wxCloseEvent,
56025 &_swigt__p_wxColour,
56026 &_swigt__p_wxCommandEvent,
56027 &_swigt__p_wxContextMenuEvent,
56028 &_swigt__p_wxControl,
56029 &_swigt__p_wxControlWithItems,
56030 &_swigt__p_wxCursor,
56031 &_swigt__p_wxDC,
56032 &_swigt__p_wxDateEvent,
56033 &_swigt__p_wxDateTime,
56034 &_swigt__p_wxDisplayChangedEvent,
56035 &_swigt__p_wxDropFilesEvent,
56036 &_swigt__p_wxDuplexMode,
56037 &_swigt__p_wxEraseEvent,
56038 &_swigt__p_wxEvent,
56039 &_swigt__p_wxEventLoop,
56040 &_swigt__p_wxEventLoopActivator,
56041 &_swigt__p_wxEvtHandler,
56042 &_swigt__p_wxFSFile,
56043 &_swigt__p_wxFileSystem,
56044 &_swigt__p_wxFileSystemHandler,
56045 &_swigt__p_wxFlexGridSizer,
56046 &_swigt__p_wxFocusEvent,
56047 &_swigt__p_wxFont,
56048 &_swigt__p_wxFrame,
56049 &_swigt__p_wxGBPosition,
56050 &_swigt__p_wxGBSizerItem,
56051 &_swigt__p_wxGBSpan,
56052 &_swigt__p_wxGIFHandler,
56053 &_swigt__p_wxGridBagSizer,
56054 &_swigt__p_wxGridSizer,
56055 &_swigt__p_wxHelpEvent__Origin,
56056 &_swigt__p_wxICOHandler,
56057 &_swigt__p_wxIconizeEvent,
56058 &_swigt__p_wxIdleEvent,
56059 &_swigt__p_wxImage,
56060 &_swigt__p_wxImageHandler,
56061 &_swigt__p_wxImageHistogram,
56062 &_swigt__p_wxImage_HSVValue,
56063 &_swigt__p_wxImage_RGBValue,
56064 &_swigt__p_wxIndividualLayoutConstraint,
56065 &_swigt__p_wxInitDialogEvent,
56066 &_swigt__p_wxInputStream,
56067 &_swigt__p_wxInternetFSHandler,
56068 &_swigt__p_wxItemContainer,
56069 &_swigt__p_wxJPEGHandler,
56070 &_swigt__p_wxKeyEvent,
56071 &_swigt__p_wxLayoutConstraints,
56072 &_swigt__p_wxMaximizeEvent,
56073 &_swigt__p_wxMemoryFSHandler,
56074 &_swigt__p_wxMenu,
56075 &_swigt__p_wxMenuBar,
56076 &_swigt__p_wxMenuBarBase,
56077 &_swigt__p_wxMenuEvent,
56078 &_swigt__p_wxMenuItem,
56079 &_swigt__p_wxMouseCaptureChangedEvent,
56080 &_swigt__p_wxMouseCaptureLostEvent,
56081 &_swigt__p_wxMouseEvent,
56082 &_swigt__p_wxMoveEvent,
56083 &_swigt__p_wxNavigationKeyEvent,
56084 &_swigt__p_wxNcPaintEvent,
56085 &_swigt__p_wxNotifyEvent,
56086 &_swigt__p_wxObject,
56087 &_swigt__p_wxOutputStream,
56088 &_swigt__p_wxPCXHandler,
56089 &_swigt__p_wxPNGHandler,
56090 &_swigt__p_wxPNMHandler,
56091 &_swigt__p_wxPaintEvent,
56092 &_swigt__p_wxPaletteChangedEvent,
56093 &_swigt__p_wxPaperSize,
56094 &_swigt__p_wxPoint,
56095 &_swigt__p_wxPoint2D,
56096 &_swigt__p_wxPropagateOnce,
56097 &_swigt__p_wxPropagationDisabler,
56098 &_swigt__p_wxPyApp,
56099 &_swigt__p_wxPyCommandEvent,
56100 &_swigt__p_wxPyDropTarget,
56101 &_swigt__p_wxPyEvent,
56102 &_swigt__p_wxPyFileSystemHandler,
56103 &_swigt__p_wxPyImageHandler,
56104 &_swigt__p_wxPyInputStream,
56105 &_swigt__p_wxPySizer,
56106 &_swigt__p_wxPyValidator,
56107 &_swigt__p_wxQuantize,
56108 &_swigt__p_wxQueryNewPaletteEvent,
56109 &_swigt__p_wxRealPoint,
56110 &_swigt__p_wxRect,
56111 &_swigt__p_wxRegion,
56112 &_swigt__p_wxScrollEvent,
56113 &_swigt__p_wxScrollWinEvent,
56114 &_swigt__p_wxSetCursorEvent,
56115 &_swigt__p_wxShowEvent,
56116 &_swigt__p_wxSize,
56117 &_swigt__p_wxSizeEvent,
56118 &_swigt__p_wxSizer,
56119 &_swigt__p_wxSizerItem,
56120 &_swigt__p_wxStaticBox,
56121 &_swigt__p_wxStaticBoxSizer,
56122 &_swigt__p_wxStdDialogButtonSizer,
56123 &_swigt__p_wxSysColourChangedEvent,
56124 &_swigt__p_wxTIFFHandler,
56125 &_swigt__p_wxToolTip,
56126 &_swigt__p_wxUpdateUIEvent,
56127 &_swigt__p_wxValidator,
56128 &_swigt__p_wxVisualAttributes,
56129 &_swigt__p_wxWindow,
56130 &_swigt__p_wxWindowCreateEvent,
56131 &_swigt__p_wxWindowDestroyEvent,
56132 &_swigt__p_wxXPMHandler,
56133 &_swigt__p_wxZipFSHandler,
56134 };
56135
56136 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
56137 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
56138 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
56139 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
56140 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
56141 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
56142 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
56143 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
56144 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
56145 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
56146 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
56147 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
56148 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
56149 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
56150 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}};
56151 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
56152 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}};
56153 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
56154 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}};
56155 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
56156 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
56157 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
56158 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
56159 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
56160 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}};
56161 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
56162 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}};
56163 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
56164 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
56165 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
56166 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
56167 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
56168 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56169 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
56170 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
56171 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
56172 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}};
56173 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
56174 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
56175 static swig_cast_info _swigc__p_wxEvtHandler[] = { {&_swigt__p_wxControl, _p_wxControlTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxEvtHandler, 0, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxEvtHandler, 0, 0},{0, 0, 0, 0}};
56176 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
56177 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
56178 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}};
56179 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}};
56180 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
56181 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
56182 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
56183 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
56184 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
56185 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
56186 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
56187 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
56188 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}};
56189 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
56190 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}};
56191 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56192 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
56193 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
56194 static swig_cast_info _swigc__p_wxImageHandler[] = { {&_swigt__p_wxImageHandler, 0, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxImageHandler, 0, 0},{0, 0, 0, 0}};
56195 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
56196 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
56197 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
56198 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
56199 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
56200 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
56201 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56202 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}};
56203 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
56204 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
56205 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
56206 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56207 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56208 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
56209 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
56210 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
56211 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
56212 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
56213 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56214 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
56215 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
56216 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
56217 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
56218 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
56219 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
56220 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
56221 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
56222 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
56223 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
56224 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
56225 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
56226 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56227 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
56228 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
56229 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
56230 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
56231 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
56232 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
56233 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
56234 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
56235 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
56236 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
56237 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
56238 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
56239 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
56240 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
56241 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
56242 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
56243 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
56244 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
56245 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
56246 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
56247 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
56248 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
56249 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
56250 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
56251 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56252 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}};
56253 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}};
56254 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
56255 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
56256 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
56257 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56258 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
56259 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
56260 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
56261 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}};
56262 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
56263 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}};
56264 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
56265 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
56266 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
56267 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56268
56269 static swig_cast_info *swig_cast_initial[] = {
56270 _swigc__p_buffer,
56271 _swigc__p_char,
56272 _swigc__p_form_ops_t,
56273 _swigc__p_int,
56274 _swigc__p_long,
56275 _swigc__p_unsigned_char,
56276 _swigc__p_unsigned_int,
56277 _swigc__p_unsigned_long,
56278 _swigc__p_wxANIHandler,
56279 _swigc__p_wxAcceleratorEntry,
56280 _swigc__p_wxAcceleratorTable,
56281 _swigc__p_wxActivateEvent,
56282 _swigc__p_wxAppTraits,
56283 _swigc__p_wxArrayString,
56284 _swigc__p_wxBMPHandler,
56285 _swigc__p_wxBitmap,
56286 _swigc__p_wxBoxSizer,
56287 _swigc__p_wxButton,
56288 _swigc__p_wxCURHandler,
56289 _swigc__p_wxCaret,
56290 _swigc__p_wxChildFocusEvent,
56291 _swigc__p_wxClipboardTextEvent,
56292 _swigc__p_wxCloseEvent,
56293 _swigc__p_wxColour,
56294 _swigc__p_wxCommandEvent,
56295 _swigc__p_wxContextMenuEvent,
56296 _swigc__p_wxControl,
56297 _swigc__p_wxControlWithItems,
56298 _swigc__p_wxCursor,
56299 _swigc__p_wxDC,
56300 _swigc__p_wxDateEvent,
56301 _swigc__p_wxDateTime,
56302 _swigc__p_wxDisplayChangedEvent,
56303 _swigc__p_wxDropFilesEvent,
56304 _swigc__p_wxDuplexMode,
56305 _swigc__p_wxEraseEvent,
56306 _swigc__p_wxEvent,
56307 _swigc__p_wxEventLoop,
56308 _swigc__p_wxEventLoopActivator,
56309 _swigc__p_wxEvtHandler,
56310 _swigc__p_wxFSFile,
56311 _swigc__p_wxFileSystem,
56312 _swigc__p_wxFileSystemHandler,
56313 _swigc__p_wxFlexGridSizer,
56314 _swigc__p_wxFocusEvent,
56315 _swigc__p_wxFont,
56316 _swigc__p_wxFrame,
56317 _swigc__p_wxGBPosition,
56318 _swigc__p_wxGBSizerItem,
56319 _swigc__p_wxGBSpan,
56320 _swigc__p_wxGIFHandler,
56321 _swigc__p_wxGridBagSizer,
56322 _swigc__p_wxGridSizer,
56323 _swigc__p_wxHelpEvent__Origin,
56324 _swigc__p_wxICOHandler,
56325 _swigc__p_wxIconizeEvent,
56326 _swigc__p_wxIdleEvent,
56327 _swigc__p_wxImage,
56328 _swigc__p_wxImageHandler,
56329 _swigc__p_wxImageHistogram,
56330 _swigc__p_wxImage_HSVValue,
56331 _swigc__p_wxImage_RGBValue,
56332 _swigc__p_wxIndividualLayoutConstraint,
56333 _swigc__p_wxInitDialogEvent,
56334 _swigc__p_wxInputStream,
56335 _swigc__p_wxInternetFSHandler,
56336 _swigc__p_wxItemContainer,
56337 _swigc__p_wxJPEGHandler,
56338 _swigc__p_wxKeyEvent,
56339 _swigc__p_wxLayoutConstraints,
56340 _swigc__p_wxMaximizeEvent,
56341 _swigc__p_wxMemoryFSHandler,
56342 _swigc__p_wxMenu,
56343 _swigc__p_wxMenuBar,
56344 _swigc__p_wxMenuBarBase,
56345 _swigc__p_wxMenuEvent,
56346 _swigc__p_wxMenuItem,
56347 _swigc__p_wxMouseCaptureChangedEvent,
56348 _swigc__p_wxMouseCaptureLostEvent,
56349 _swigc__p_wxMouseEvent,
56350 _swigc__p_wxMoveEvent,
56351 _swigc__p_wxNavigationKeyEvent,
56352 _swigc__p_wxNcPaintEvent,
56353 _swigc__p_wxNotifyEvent,
56354 _swigc__p_wxObject,
56355 _swigc__p_wxOutputStream,
56356 _swigc__p_wxPCXHandler,
56357 _swigc__p_wxPNGHandler,
56358 _swigc__p_wxPNMHandler,
56359 _swigc__p_wxPaintEvent,
56360 _swigc__p_wxPaletteChangedEvent,
56361 _swigc__p_wxPaperSize,
56362 _swigc__p_wxPoint,
56363 _swigc__p_wxPoint2D,
56364 _swigc__p_wxPropagateOnce,
56365 _swigc__p_wxPropagationDisabler,
56366 _swigc__p_wxPyApp,
56367 _swigc__p_wxPyCommandEvent,
56368 _swigc__p_wxPyDropTarget,
56369 _swigc__p_wxPyEvent,
56370 _swigc__p_wxPyFileSystemHandler,
56371 _swigc__p_wxPyImageHandler,
56372 _swigc__p_wxPyInputStream,
56373 _swigc__p_wxPySizer,
56374 _swigc__p_wxPyValidator,
56375 _swigc__p_wxQuantize,
56376 _swigc__p_wxQueryNewPaletteEvent,
56377 _swigc__p_wxRealPoint,
56378 _swigc__p_wxRect,
56379 _swigc__p_wxRegion,
56380 _swigc__p_wxScrollEvent,
56381 _swigc__p_wxScrollWinEvent,
56382 _swigc__p_wxSetCursorEvent,
56383 _swigc__p_wxShowEvent,
56384 _swigc__p_wxSize,
56385 _swigc__p_wxSizeEvent,
56386 _swigc__p_wxSizer,
56387 _swigc__p_wxSizerItem,
56388 _swigc__p_wxStaticBox,
56389 _swigc__p_wxStaticBoxSizer,
56390 _swigc__p_wxStdDialogButtonSizer,
56391 _swigc__p_wxSysColourChangedEvent,
56392 _swigc__p_wxTIFFHandler,
56393 _swigc__p_wxToolTip,
56394 _swigc__p_wxUpdateUIEvent,
56395 _swigc__p_wxValidator,
56396 _swigc__p_wxVisualAttributes,
56397 _swigc__p_wxWindow,
56398 _swigc__p_wxWindowCreateEvent,
56399 _swigc__p_wxWindowDestroyEvent,
56400 _swigc__p_wxXPMHandler,
56401 _swigc__p_wxZipFSHandler,
56402 };
56403
56404
56405 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
56406
56407 static swig_const_info swig_const_table[] = {
56408 {0, 0, 0, 0.0, 0, 0}};
56409
56410 #ifdef __cplusplus
56411 }
56412 #endif
56413 /* -----------------------------------------------------------------------------
56414 * Type initialization:
56415 * This problem is tough by the requirement that no dynamic
56416 * memory is used. Also, since swig_type_info structures store pointers to
56417 * swig_cast_info structures and swig_cast_info structures store pointers back
56418 * to swig_type_info structures, we need some lookup code at initialization.
56419 * The idea is that swig generates all the structures that are needed.
56420 * The runtime then collects these partially filled structures.
56421 * The SWIG_InitializeModule function takes these initial arrays out of
56422 * swig_module, and does all the lookup, filling in the swig_module.types
56423 * array with the correct data and linking the correct swig_cast_info
56424 * structures together.
56425 *
56426 * The generated swig_type_info structures are assigned staticly to an initial
56427 * array. We just loop though that array, and handle each type individually.
56428 * First we lookup if this type has been already loaded, and if so, use the
56429 * loaded structure instead of the generated one. Then we have to fill in the
56430 * cast linked list. The cast data is initially stored in something like a
56431 * two-dimensional array. Each row corresponds to a type (there are the same
56432 * number of rows as there are in the swig_type_initial array). Each entry in
56433 * a column is one of the swig_cast_info structures for that type.
56434 * The cast_initial array is actually an array of arrays, because each row has
56435 * a variable number of columns. So to actually build the cast linked list,
56436 * we find the array of casts associated with the type, and loop through it
56437 * adding the casts to the list. The one last trick we need to do is making
56438 * sure the type pointer in the swig_cast_info struct is correct.
56439 *
56440 * First off, we lookup the cast->type name to see if it is already loaded.
56441 * There are three cases to handle:
56442 * 1) If the cast->type has already been loaded AND the type we are adding
56443 * casting info to has not been loaded (it is in this module), THEN we
56444 * replace the cast->type pointer with the type pointer that has already
56445 * been loaded.
56446 * 2) If BOTH types (the one we are adding casting info to, and the
56447 * cast->type) are loaded, THEN the cast info has already been loaded by
56448 * the previous module so we just ignore it.
56449 * 3) Finally, if cast->type has not already been loaded, then we add that
56450 * swig_cast_info to the linked list (because the cast->type) pointer will
56451 * be correct.
56452 * ----------------------------------------------------------------------------- */
56453
56454 #ifdef __cplusplus
56455 extern "C" {
56456 #if 0
56457 } /* c-mode */
56458 #endif
56459 #endif
56460
56461 #if 0
56462 #define SWIGRUNTIME_DEBUG
56463 #endif
56464
56465 SWIGRUNTIME void
56466 SWIG_InitializeModule(void *clientdata) {
56467 size_t i;
56468 swig_module_info *module_head;
56469 static int init_run = 0;
56470
56471 clientdata = clientdata;
56472
56473 if (init_run) return;
56474 init_run = 1;
56475
56476 /* Initialize the swig_module */
56477 swig_module.type_initial = swig_type_initial;
56478 swig_module.cast_initial = swig_cast_initial;
56479
56480 /* Try and load any already created modules */
56481 module_head = SWIG_GetModule(clientdata);
56482 if (module_head) {
56483 swig_module.next = module_head->next;
56484 module_head->next = &swig_module;
56485 } else {
56486 /* This is the first module loaded */
56487 swig_module.next = &swig_module;
56488 SWIG_SetModule(clientdata, &swig_module);
56489 }
56490
56491 /* Now work on filling in swig_module.types */
56492 #ifdef SWIGRUNTIME_DEBUG
56493 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
56494 #endif
56495 for (i = 0; i < swig_module.size; ++i) {
56496 swig_type_info *type = 0;
56497 swig_type_info *ret;
56498 swig_cast_info *cast;
56499
56500 #ifdef SWIGRUNTIME_DEBUG
56501 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
56502 #endif
56503
56504 /* if there is another module already loaded */
56505 if (swig_module.next != &swig_module) {
56506 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
56507 }
56508 if (type) {
56509 /* Overwrite clientdata field */
56510 #ifdef SWIGRUNTIME_DEBUG
56511 printf("SWIG_InitializeModule: found type %s\n", type->name);
56512 #endif
56513 if (swig_module.type_initial[i]->clientdata) {
56514 type->clientdata = swig_module.type_initial[i]->clientdata;
56515 #ifdef SWIGRUNTIME_DEBUG
56516 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
56517 #endif
56518 }
56519 } else {
56520 type = swig_module.type_initial[i];
56521 }
56522
56523 /* Insert casting types */
56524 cast = swig_module.cast_initial[i];
56525 while (cast->type) {
56526 /* Don't need to add information already in the list */
56527 ret = 0;
56528 #ifdef SWIGRUNTIME_DEBUG
56529 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
56530 #endif
56531 if (swig_module.next != &swig_module) {
56532 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
56533 #ifdef SWIGRUNTIME_DEBUG
56534 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
56535 #endif
56536 }
56537 if (ret) {
56538 if (type == swig_module.type_initial[i]) {
56539 #ifdef SWIGRUNTIME_DEBUG
56540 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
56541 #endif
56542 cast->type = ret;
56543 ret = 0;
56544 } else {
56545 /* Check for casting already in the list */
56546 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
56547 #ifdef SWIGRUNTIME_DEBUG
56548 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
56549 #endif
56550 if (!ocast) ret = 0;
56551 }
56552 }
56553
56554 if (!ret) {
56555 #ifdef SWIGRUNTIME_DEBUG
56556 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
56557 #endif
56558 if (type->cast) {
56559 type->cast->prev = cast;
56560 cast->next = type->cast;
56561 }
56562 type->cast = cast;
56563 }
56564 cast++;
56565 }
56566 /* Set entry in modules->types array equal to the type */
56567 swig_module.types[i] = type;
56568 }
56569 swig_module.types[i] = 0;
56570
56571 #ifdef SWIGRUNTIME_DEBUG
56572 printf("**** SWIG_InitializeModule: Cast List ******\n");
56573 for (i = 0; i < swig_module.size; ++i) {
56574 int j = 0;
56575 swig_cast_info *cast = swig_module.cast_initial[i];
56576 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
56577 while (cast->type) {
56578 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
56579 cast++;
56580 ++j;
56581 }
56582 printf("---- Total casts: %d\n",j);
56583 }
56584 printf("**** SWIG_InitializeModule: Cast List ******\n");
56585 #endif
56586 }
56587
56588 /* This function will propagate the clientdata field of type to
56589 * any new swig_type_info structures that have been added into the list
56590 * of equivalent types. It is like calling
56591 * SWIG_TypeClientData(type, clientdata) a second time.
56592 */
56593 SWIGRUNTIME void
56594 SWIG_PropagateClientData(void) {
56595 size_t i;
56596 swig_cast_info *equiv;
56597 static int init_run = 0;
56598
56599 if (init_run) return;
56600 init_run = 1;
56601
56602 for (i = 0; i < swig_module.size; i++) {
56603 if (swig_module.types[i]->clientdata) {
56604 equiv = swig_module.types[i]->cast;
56605 while (equiv) {
56606 if (!equiv->converter) {
56607 if (equiv->type && !equiv->type->clientdata)
56608 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
56609 }
56610 equiv = equiv->next;
56611 }
56612 }
56613 }
56614 }
56615
56616 #ifdef __cplusplus
56617 #if 0
56618 {
56619 /* c-mode */
56620 #endif
56621 }
56622 #endif
56623
56624
56625
56626 #ifdef __cplusplus
56627 extern "C" {
56628 #endif
56629
56630 /* Python-specific SWIG API */
56631 #define SWIG_newvarlink() SWIG_Python_newvarlink()
56632 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
56633 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
56634
56635 /* -----------------------------------------------------------------------------
56636 * global variable support code.
56637 * ----------------------------------------------------------------------------- */
56638
56639 typedef struct swig_globalvar {
56640 char *name; /* Name of global variable */
56641 PyObject *(*get_attr)(void); /* Return the current value */
56642 int (*set_attr)(PyObject *); /* Set the value */
56643 struct swig_globalvar *next;
56644 } swig_globalvar;
56645
56646 typedef struct swig_varlinkobject {
56647 PyObject_HEAD
56648 swig_globalvar *vars;
56649 } swig_varlinkobject;
56650
56651 SWIGINTERN PyObject *
56652 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
56653 return PyString_FromString("<Swig global variables>");
56654 }
56655
56656 SWIGINTERN PyObject *
56657 swig_varlink_str(swig_varlinkobject *v) {
56658 PyObject *str = PyString_FromString("(");
56659 swig_globalvar *var;
56660 for (var = v->vars; var; var=var->next) {
56661 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
56662 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
56663 }
56664 PyString_ConcatAndDel(&str,PyString_FromString(")"));
56665 return str;
56666 }
56667
56668 SWIGINTERN int
56669 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
56670 PyObject *str = swig_varlink_str(v);
56671 fprintf(fp,"Swig global variables ");
56672 fprintf(fp,"%s\n", PyString_AsString(str));
56673 Py_DECREF(str);
56674 return 0;
56675 }
56676
56677 SWIGINTERN void
56678 swig_varlink_dealloc(swig_varlinkobject *v) {
56679 swig_globalvar *var = v->vars;
56680 while (var) {
56681 swig_globalvar *n = var->next;
56682 free(var->name);
56683 free(var);
56684 var = n;
56685 }
56686 }
56687
56688 SWIGINTERN PyObject *
56689 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
56690 PyObject *res = NULL;
56691 swig_globalvar *var = v->vars;
56692 while (var) {
56693 if (strcmp(var->name,n) == 0) {
56694 res = (*var->get_attr)();
56695 break;
56696 }
56697 var = var->next;
56698 }
56699 if (res == NULL && !PyErr_Occurred()) {
56700 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
56701 }
56702 return res;
56703 }
56704
56705 SWIGINTERN int
56706 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
56707 int res = 1;
56708 swig_globalvar *var = v->vars;
56709 while (var) {
56710 if (strcmp(var->name,n) == 0) {
56711 res = (*var->set_attr)(p);
56712 break;
56713 }
56714 var = var->next;
56715 }
56716 if (res == 1 && !PyErr_Occurred()) {
56717 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
56718 }
56719 return res;
56720 }
56721
56722 SWIGINTERN PyTypeObject*
56723 swig_varlink_type(void) {
56724 static char varlink__doc__[] = "Swig var link object";
56725 static PyTypeObject varlink_type;
56726 static int type_init = 0;
56727 if (!type_init) {
56728 const PyTypeObject tmp
56729 = {
56730 PyObject_HEAD_INIT(NULL)
56731 0, /* Number of items in variable part (ob_size) */
56732 (char *)"swigvarlink", /* Type name (tp_name) */
56733 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
56734 0, /* Itemsize (tp_itemsize) */
56735 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
56736 (printfunc) swig_varlink_print, /* Print (tp_print) */
56737 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
56738 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
56739 0, /* tp_compare */
56740 (reprfunc) swig_varlink_repr, /* tp_repr */
56741 0, /* tp_as_number */
56742 0, /* tp_as_sequence */
56743 0, /* tp_as_mapping */
56744 0, /* tp_hash */
56745 0, /* tp_call */
56746 (reprfunc)swig_varlink_str, /* tp_str */
56747 0, /* tp_getattro */
56748 0, /* tp_setattro */
56749 0, /* tp_as_buffer */
56750 0, /* tp_flags */
56751 varlink__doc__, /* tp_doc */
56752 0, /* tp_traverse */
56753 0, /* tp_clear */
56754 0, /* tp_richcompare */
56755 0, /* tp_weaklistoffset */
56756 #if PY_VERSION_HEX >= 0x02020000
56757 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
56758 #endif
56759 #if PY_VERSION_HEX >= 0x02030000
56760 0, /* tp_del */
56761 #endif
56762 #ifdef COUNT_ALLOCS
56763 0,0,0,0 /* tp_alloc -> tp_next */
56764 #endif
56765 };
56766 varlink_type = tmp;
56767 varlink_type.ob_type = &PyType_Type;
56768 type_init = 1;
56769 }
56770 return &varlink_type;
56771 }
56772
56773 /* Create a variable linking object for use later */
56774 SWIGINTERN PyObject *
56775 SWIG_Python_newvarlink(void) {
56776 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
56777 if (result) {
56778 result->vars = 0;
56779 }
56780 return ((PyObject*) result);
56781 }
56782
56783 SWIGINTERN void
56784 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
56785 swig_varlinkobject *v = (swig_varlinkobject *) p;
56786 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
56787 if (gv) {
56788 size_t size = strlen(name)+1;
56789 gv->name = (char *)malloc(size);
56790 if (gv->name) {
56791 strncpy(gv->name,name,size);
56792 gv->get_attr = get_attr;
56793 gv->set_attr = set_attr;
56794 gv->next = v->vars;
56795 }
56796 }
56797 v->vars = gv;
56798 }
56799
56800 SWIGINTERN PyObject *
56801 SWIG_globals() {
56802 static PyObject *_SWIG_globals = 0;
56803 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
56804 return _SWIG_globals;
56805 }
56806
56807 /* -----------------------------------------------------------------------------
56808 * constants/methods manipulation
56809 * ----------------------------------------------------------------------------- */
56810
56811 /* Install Constants */
56812 SWIGINTERN void
56813 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
56814 PyObject *obj = 0;
56815 size_t i;
56816 for (i = 0; constants[i].type; ++i) {
56817 switch(constants[i].type) {
56818 case SWIG_PY_POINTER:
56819 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
56820 break;
56821 case SWIG_PY_BINARY:
56822 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
56823 break;
56824 default:
56825 obj = 0;
56826 break;
56827 }
56828 if (obj) {
56829 PyDict_SetItemString(d, constants[i].name, obj);
56830 Py_DECREF(obj);
56831 }
56832 }
56833 }
56834
56835 /* -----------------------------------------------------------------------------*/
56836 /* Fix SwigMethods to carry the callback ptrs when needed */
56837 /* -----------------------------------------------------------------------------*/
56838
56839 SWIGINTERN void
56840 SWIG_Python_FixMethods(PyMethodDef *methods,
56841 swig_const_info *const_table,
56842 swig_type_info **types,
56843 swig_type_info **types_initial) {
56844 size_t i;
56845 for (i = 0; methods[i].ml_name; ++i) {
56846 const char *c = methods[i].ml_doc;
56847 if (c && (c = strstr(c, "swig_ptr: "))) {
56848 int j;
56849 swig_const_info *ci = 0;
56850 const char *name = c + 10;
56851 for (j = 0; const_table[j].type; ++j) {
56852 if (strncmp(const_table[j].name, name,
56853 strlen(const_table[j].name)) == 0) {
56854 ci = &(const_table[j]);
56855 break;
56856 }
56857 }
56858 if (ci) {
56859 size_t shift = (ci->ptype) - types;
56860 swig_type_info *ty = types_initial[shift];
56861 size_t ldoc = (c - methods[i].ml_doc);
56862 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
56863 char *ndoc = (char*)malloc(ldoc + lptr + 10);
56864 if (ndoc) {
56865 char *buff = ndoc;
56866 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
56867 if (ptr) {
56868 strncpy(buff, methods[i].ml_doc, ldoc);
56869 buff += ldoc;
56870 strncpy(buff, "swig_ptr: ", 10);
56871 buff += 10;
56872 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
56873 methods[i].ml_doc = ndoc;
56874 }
56875 }
56876 }
56877 }
56878 }
56879 }
56880
56881 #ifdef __cplusplus
56882 }
56883 #endif
56884
56885 /* -----------------------------------------------------------------------------*
56886 * Partial Init method
56887 * -----------------------------------------------------------------------------*/
56888
56889 #ifdef __cplusplus
56890 extern "C"
56891 #endif
56892 SWIGEXPORT void SWIG_init(void) {
56893 PyObject *m, *d;
56894
56895 /* Fix SwigMethods to carry the callback ptrs when needed */
56896 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
56897
56898 m = Py_InitModule((char *) SWIG_name, SwigMethods);
56899 d = PyModule_GetDict(m);
56900
56901 SWIG_InitializeModule(0);
56902 SWIG_InstallConstants(d,swig_const_table);
56903
56904
56905
56906 #ifndef wxPyUSE_EXPORT
56907 // Make our API structure a CObject so other modules can import it
56908 // from this module.
56909 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
56910 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
56911 Py_XDECREF(cobj);
56912 #endif
56913
56914 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
56915 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
56916 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
56917 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
56918 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
56919 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
56920 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
56921 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
56922 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
56923 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
56924 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
56925 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
56926 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
56927 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
56928 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
56929 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
56930 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
56931 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
56932 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
56933 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
56934 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
56935 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
56936 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
56937 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
56938 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
56939 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
56940 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
56941 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
56942 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
56943 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
56944 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
56945 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
56946 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
56947 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
56948 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
56949 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
56950 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
56951 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
56952 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
56953 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
56954 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
56955 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
56956 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
56957 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
56958 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
56959 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
56960 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
56961 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
56962 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
56963 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
56964 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
56965 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
56966 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
56967 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
56968 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
56969 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
56970 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
56971 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
56972 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
56973 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
56974 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
56975 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
56976 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
56977 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
56978 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
56979 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
56980 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
56981 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
56982 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
56983 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
56984 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
56985 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
56986 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
56987 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
56988 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
56989 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
56990 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
56991 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
56992 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
56993 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
56994 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
56995 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
56996 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
56997 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
56998 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
56999 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
57000 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
57001 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
57002 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
57003 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
57004 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
57005 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
57006 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
57007 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
57008 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
57009 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
57010 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
57011 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
57012 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
57013 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
57014 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
57015 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
57016 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
57017 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
57018 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
57019 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
57020 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
57021 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
57022 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
57023 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
57024 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
57025 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
57026 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
57027 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
57028 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
57029 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
57030 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
57031 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
57032 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
57033 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
57034 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
57035 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
57036 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
57037 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
57038 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
57039 SWIG_Python_SetConstant(d, "ID_EDIT",SWIG_From_int(static_cast< int >(wxID_EDIT)));
57040 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
57041 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
57042 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
57043 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
57044 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
57045 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
57046 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
57047 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
57048 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
57049 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
57050 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
57051 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
57052 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
57053 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
57054 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
57055 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
57056 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
57057 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
57058 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
57059 SWIG_Python_SetConstant(d, "ID_FILE",SWIG_From_int(static_cast< int >(wxID_FILE)));
57060 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
57061 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
57062 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
57063 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
57064 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
57065 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
57066 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
57067 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
57068 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
57069 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
57070 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
57071 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
57072 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
57073 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
57074 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
57075 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
57076 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
57077 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
57078 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
57079 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
57080 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
57081 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
57082 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
57083 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
57084 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
57085 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
57086 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
57087 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
57088 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
57089 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
57090 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
57091 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
57092 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
57093 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
57094 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
57095 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
57096 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
57097 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
57098 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
57099 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
57100 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
57101 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
57102 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
57103 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
57104 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
57105 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
57106 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
57107 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
57108 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
57109 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
57110 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
57111 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
57112 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
57113 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
57114 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
57115 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
57116 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
57117 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
57118 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
57119 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
57120 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
57121 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
57122 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
57123 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
57124 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
57125 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
57126 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
57127 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
57128 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
57129 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
57130 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
57131 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
57132 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
57133 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
57134 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
57135 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
57136 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
57137 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
57138 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
57139 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
57140 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
57141 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
57142 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
57143 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
57144 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
57145 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
57146 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
57147 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
57148 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
57149 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
57150 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
57151 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
57152 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
57153 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
57154 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
57155 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
57156 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
57157 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
57158 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
57159 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
57160 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
57161 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
57162 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
57163 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
57164 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
57165 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
57166 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
57167 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
57168 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
57169 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
57170 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
57171 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
57172 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
57173 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
57174 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
57175 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
57176 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
57177 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
57178 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
57179 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
57180 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
57181 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
57182 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
57183 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
57184 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
57185 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
57186 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
57187 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
57188 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
57189 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
57190 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
57191 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
57192 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
57193 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
57194 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
57195 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
57196 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
57197 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
57198 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
57199 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
57200 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
57201 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
57202 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
57203 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
57204 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
57205 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
57206 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
57207 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
57208 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
57209 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
57210 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
57211 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
57212 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
57213 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
57214 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
57215 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
57216 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
57217 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
57218 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
57219 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
57220 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
57221 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
57222 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
57223 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
57224 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
57225 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
57226 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
57227 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
57228 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
57229 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
57230 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
57231 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
57232 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
57233 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
57234 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
57235 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
57236 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
57237 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
57238 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
57239 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
57240 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
57241 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
57242 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
57243 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
57244 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
57245 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
57246 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
57247 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
57248 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
57249 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
57250 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
57251 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
57252 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
57253 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
57254 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
57255 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
57256 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
57257 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
57258 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
57259 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
57260 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
57261 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
57262 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
57263 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
57264 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
57265 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
57266 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
57267 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
57268 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
57269 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
57270 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
57271 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
57272 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
57273 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
57274 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
57275 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
57276 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
57277 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
57278 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
57279 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
57280 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
57281 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
57282 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
57283 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
57284 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
57285 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
57286 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
57287 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
57288 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
57289 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
57290 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
57291 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
57292 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
57293 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
57294 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
57295 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
57296 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
57297 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
57298 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
57299 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
57300 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
57301 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
57302 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
57303 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
57304 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
57305 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
57306 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
57307 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
57308 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
57309 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
57310 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
57311 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
57312 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
57313 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
57314 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
57315 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
57316 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
57317 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
57318 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
57319 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
57320 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
57321 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
57322 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
57323 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
57324 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
57325 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
57326 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
57327 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
57328 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
57329 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
57330 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
57331 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
57332 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
57333 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
57334 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
57335 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
57336 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
57337 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
57338 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
57339 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
57340 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
57341 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
57342 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
57343 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
57344 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
57345 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
57346 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
57347 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
57348 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
57349 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
57350 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
57351 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
57352 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
57353 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
57354 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
57355 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
57356 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
57357 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
57358 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
57359 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
57360 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
57361 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
57362 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
57363 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
57364 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
57365 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
57366 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
57367 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
57368 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
57369 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
57370 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
57371 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
57372 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
57373 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
57374 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
57375 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
57376 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
57377 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
57378 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
57379 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
57380 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
57381 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
57382 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
57383 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
57384 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
57385 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
57386 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
57387 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
57388 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
57389 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
57390 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
57391 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
57392 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
57393 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
57394 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
57395 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
57396 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
57397 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
57398 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
57399 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
57400 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
57401 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
57402 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
57403 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
57404 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
57405 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
57406 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
57407 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
57408 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
57409 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
57410 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
57411 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
57412 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
57413 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
57414 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
57415 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
57416 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
57417 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
57418 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
57419 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
57420 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
57421 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
57422 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
57423 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
57424 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
57425 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
57426 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
57427 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
57428 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
57429 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
57430 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
57431 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
57432 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
57433 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
57434 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
57435 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
57436 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
57437 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
57438 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
57439 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
57440 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
57441 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
57442 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
57443 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
57444 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
57445 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
57446 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
57447 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
57448 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
57449 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
57450 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
57451 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
57452 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
57453 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
57454 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
57455 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
57456 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
57457 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
57458 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
57459 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
57460 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
57461 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
57462 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
57463 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
57464 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
57465 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
57466 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
57467 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
57468 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
57469 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
57470 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
57471 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
57472 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
57473 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
57474 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
57475 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
57476 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
57477 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
57478 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
57479 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
57480 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
57481 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
57482 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
57483 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
57484 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
57485 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
57486 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
57487 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
57488 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
57489 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
57490 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
57491 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
57492 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
57493 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
57494 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
57495 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
57496 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
57497 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
57498 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
57499 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
57500 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
57501 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
57502 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
57503 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
57504 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
57505 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
57506 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
57507 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
57508 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
57509 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
57510 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
57511 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
57512 SWIG_Python_SetConstant(d, "Layout_Default",SWIG_From_int(static_cast< int >(wxLayout_Default)));
57513 SWIG_Python_SetConstant(d, "Layout_LeftToRight",SWIG_From_int(static_cast< int >(wxLayout_LeftToRight)));
57514 SWIG_Python_SetConstant(d, "Layout_RightToLeft",SWIG_From_int(static_cast< int >(wxLayout_RightToLeft)));
57515 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
57516 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
57517 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
57518 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
57519 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
57520 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
57521 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
57522 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
57523 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
57524 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
57525 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
57526 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
57527 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
57528 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
57529 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
57530 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
57531 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
57532 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
57533 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
57534 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
57535 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
57536 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
57537 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
57538 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
57539 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
57540 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
57541 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
57542 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
57543 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
57544 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
57545 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
57546 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
57547 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
57548 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
57549 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
57550 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
57551 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
57552 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
57553 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
57554 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
57555 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
57556 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
57557 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
57558 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
57559 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
57560 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
57561 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
57562 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
57563 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
57564 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
57565 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
57566 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
57567 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
57568 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
57569 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
57570 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
57571 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
57572 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
57573
57574 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
57575
57576
57577 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
57578
57579 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
57580 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
57581 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
57582 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
57583 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
57584 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
57585 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
57586 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
57587 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
57588 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
57589 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
57590 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
57591 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
57592 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
57593 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
57594 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
57595 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
57596 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
57597 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
57598 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
57599 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
57600 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
57601 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
57602 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
57603 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
57604 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
57605 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
57606 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
57607 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
57608 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
57609 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
57610 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
57611 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
57612 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
57613 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
57614 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
57615 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
57616 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
57617 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
57618 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
57619 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
57620 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
57621 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
57622 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
57623 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
57624 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
57625 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
57626 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
57627 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
57628 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
57629 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
57630 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
57631 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
57632 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
57633 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
57634 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
57635 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
57636 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
57637 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
57638 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
57639 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
57640 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
57641 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
57642 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
57643 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
57644 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
57645 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
57646 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
57647 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
57648 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
57649 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
57650 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
57651 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
57652 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
57653 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
57654 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
57655 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
57656 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
57657 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
57658 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
57659 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
57660 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
57661 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
57662 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
57663 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
57664 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
57665 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
57666 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
57667 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
57668 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
57669 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
57670 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
57671 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
57672 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
57673 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
57674 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
57675 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
57676 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
57677 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
57678 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
57679 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
57680 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
57681 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
57682 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
57683 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
57684 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
57685 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
57686 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
57687 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
57688 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
57689 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
57690 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
57691 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
57692 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
57693 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
57694 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
57695 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
57696 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
57697 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
57698 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
57699 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
57700 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
57701 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
57702 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
57703 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
57704 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
57705 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
57706 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
57707 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
57708 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
57709 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
57710 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
57711 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
57712 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
57713 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
57714 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
57715 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
57716 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
57717 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
57718 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
57719 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
57720 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
57721 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
57722 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
57723 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
57724 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
57725 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
57726 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
57727 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
57728 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
57729 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
57730 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
57731 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
57732 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
57733 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
57734 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
57735 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
57736 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
57737 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
57738 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
57739 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
57740 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
57741 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
57742 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
57743 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
57744 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
57745 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
57746 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
57747 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
57748 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
57749 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
57750 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
57751 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
57752 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
57753 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
57754 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
57755 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
57756 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
57757 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
57758 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
57759 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
57760 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
57761 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
57762 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
57763 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
57764 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
57765 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
57766 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
57767 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
57768 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
57769 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
57770 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
57771 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
57772 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
57773 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
57774 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
57775 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
57776 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
57777 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
57778 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
57779 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
57780 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
57781 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
57782 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
57783 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
57784 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
57785 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
57786 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
57787 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
57788 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
57789 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
57790 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
57791
57792 // Initialize threading, some globals and such
57793 __wxPyPreStart(d);
57794
57795
57796 // Although these are defined in __version__ they need to be here too so
57797 // that an assert can be done to ensure that the wxPython and the wxWindows
57798 // versions match.
57799 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
57800 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
57801 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
57802
57803 }
57804
wxWidgets (Impactor)