]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/mac/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
reSWIGged
[wxWidgets.git] / wxPython / src / mac / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_buffer swig_types[0]
2467 #define SWIGTYPE_p_char swig_types[1]
2468 #define SWIGTYPE_p_form_ops_t swig_types[2]
2469 #define SWIGTYPE_p_int swig_types[3]
2470 #define SWIGTYPE_p_long swig_types[4]
2471 #define SWIGTYPE_p_unsigned_char swig_types[5]
2472 #define SWIGTYPE_p_unsigned_int swig_types[6]
2473 #define SWIGTYPE_p_unsigned_long swig_types[7]
2474 #define SWIGTYPE_p_wxANIHandler swig_types[8]
2475 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
2476 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
2477 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
2478 #define SWIGTYPE_p_wxAppTraits swig_types[12]
2479 #define SWIGTYPE_p_wxArrayString swig_types[13]
2480 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2481 #define SWIGTYPE_p_wxBitmap swig_types[15]
2482 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
2483 #define SWIGTYPE_p_wxButton swig_types[17]
2484 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2485 #define SWIGTYPE_p_wxCaret swig_types[19]
2486 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2487 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[21]
2488 #define SWIGTYPE_p_wxCloseEvent swig_types[22]
2489 #define SWIGTYPE_p_wxColour swig_types[23]
2490 #define SWIGTYPE_p_wxCommandEvent swig_types[24]
2491 #define SWIGTYPE_p_wxContextMenuEvent swig_types[25]
2492 #define SWIGTYPE_p_wxControl swig_types[26]
2493 #define SWIGTYPE_p_wxControlWithItems swig_types[27]
2494 #define SWIGTYPE_p_wxCursor swig_types[28]
2495 #define SWIGTYPE_p_wxDC swig_types[29]
2496 #define SWIGTYPE_p_wxDateEvent swig_types[30]
2497 #define SWIGTYPE_p_wxDateTime swig_types[31]
2498 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[32]
2499 #define SWIGTYPE_p_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_DisplayAvailable(){
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_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6828 PyObject *resultobj = 0;
6829 wxRect *arg1 = (wxRect *) 0 ;
6830 int 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_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6840 }
6841 arg1 = reinterpret_cast< wxRect * >(argp1);
6842 {
6843 PyThreadState* __tstate = wxPyBeginAllowThreads();
6844 result = (int)((wxRect const *)arg1)->GetLeft();
6845 wxPyEndAllowThreads(__tstate);
6846 if (PyErr_Occurred()) SWIG_fail;
6847 }
6848 resultobj = SWIG_From_int(static_cast< int >(result));
6849 return resultobj;
6850 fail:
6851 return NULL;
6852 }
6853
6854
6855 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6856 PyObject *resultobj = 0;
6857 wxRect *arg1 = (wxRect *) 0 ;
6858 int result;
6859 void *argp1 = 0 ;
6860 int res1 = 0 ;
6861 PyObject *swig_obj[1] ;
6862
6863 if (!args) SWIG_fail;
6864 swig_obj[0] = args;
6865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6866 if (!SWIG_IsOK(res1)) {
6867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
6868 }
6869 arg1 = reinterpret_cast< wxRect * >(argp1);
6870 {
6871 PyThreadState* __tstate = wxPyBeginAllowThreads();
6872 result = (int)((wxRect const *)arg1)->GetTop();
6873 wxPyEndAllowThreads(__tstate);
6874 if (PyErr_Occurred()) SWIG_fail;
6875 }
6876 resultobj = SWIG_From_int(static_cast< int >(result));
6877 return resultobj;
6878 fail:
6879 return NULL;
6880 }
6881
6882
6883 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6884 PyObject *resultobj = 0;
6885 wxRect *arg1 = (wxRect *) 0 ;
6886 int result;
6887 void *argp1 = 0 ;
6888 int res1 = 0 ;
6889 PyObject *swig_obj[1] ;
6890
6891 if (!args) SWIG_fail;
6892 swig_obj[0] = args;
6893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6894 if (!SWIG_IsOK(res1)) {
6895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
6896 }
6897 arg1 = reinterpret_cast< wxRect * >(argp1);
6898 {
6899 PyThreadState* __tstate = wxPyBeginAllowThreads();
6900 result = (int)((wxRect const *)arg1)->GetBottom();
6901 wxPyEndAllowThreads(__tstate);
6902 if (PyErr_Occurred()) SWIG_fail;
6903 }
6904 resultobj = SWIG_From_int(static_cast< int >(result));
6905 return resultobj;
6906 fail:
6907 return NULL;
6908 }
6909
6910
6911 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6912 PyObject *resultobj = 0;
6913 wxRect *arg1 = (wxRect *) 0 ;
6914 int result;
6915 void *argp1 = 0 ;
6916 int res1 = 0 ;
6917 PyObject *swig_obj[1] ;
6918
6919 if (!args) SWIG_fail;
6920 swig_obj[0] = args;
6921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6922 if (!SWIG_IsOK(res1)) {
6923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6924 }
6925 arg1 = reinterpret_cast< wxRect * >(argp1);
6926 {
6927 PyThreadState* __tstate = wxPyBeginAllowThreads();
6928 result = (int)((wxRect const *)arg1)->GetRight();
6929 wxPyEndAllowThreads(__tstate);
6930 if (PyErr_Occurred()) SWIG_fail;
6931 }
6932 resultobj = SWIG_From_int(static_cast< int >(result));
6933 return resultobj;
6934 fail:
6935 return NULL;
6936 }
6937
6938
6939 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6940 PyObject *resultobj = 0;
6941 wxRect *arg1 = (wxRect *) 0 ;
6942 int arg2 ;
6943 void *argp1 = 0 ;
6944 int res1 = 0 ;
6945 int val2 ;
6946 int ecode2 = 0 ;
6947 PyObject * obj0 = 0 ;
6948 PyObject * obj1 = 0 ;
6949 char * kwnames[] = {
6950 (char *) "self",(char *) "left", NULL
6951 };
6952
6953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6955 if (!SWIG_IsOK(res1)) {
6956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6957 }
6958 arg1 = reinterpret_cast< wxRect * >(argp1);
6959 ecode2 = SWIG_AsVal_int(obj1, &val2);
6960 if (!SWIG_IsOK(ecode2)) {
6961 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
6962 }
6963 arg2 = static_cast< int >(val2);
6964 {
6965 PyThreadState* __tstate = wxPyBeginAllowThreads();
6966 (arg1)->SetLeft(arg2);
6967 wxPyEndAllowThreads(__tstate);
6968 if (PyErr_Occurred()) SWIG_fail;
6969 }
6970 resultobj = SWIG_Py_Void();
6971 return resultobj;
6972 fail:
6973 return NULL;
6974 }
6975
6976
6977 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6978 PyObject *resultobj = 0;
6979 wxRect *arg1 = (wxRect *) 0 ;
6980 int arg2 ;
6981 void *argp1 = 0 ;
6982 int res1 = 0 ;
6983 int val2 ;
6984 int ecode2 = 0 ;
6985 PyObject * obj0 = 0 ;
6986 PyObject * obj1 = 0 ;
6987 char * kwnames[] = {
6988 (char *) "self",(char *) "right", NULL
6989 };
6990
6991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
6992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6993 if (!SWIG_IsOK(res1)) {
6994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
6995 }
6996 arg1 = reinterpret_cast< wxRect * >(argp1);
6997 ecode2 = SWIG_AsVal_int(obj1, &val2);
6998 if (!SWIG_IsOK(ecode2)) {
6999 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
7000 }
7001 arg2 = static_cast< int >(val2);
7002 {
7003 PyThreadState* __tstate = wxPyBeginAllowThreads();
7004 (arg1)->SetRight(arg2);
7005 wxPyEndAllowThreads(__tstate);
7006 if (PyErr_Occurred()) SWIG_fail;
7007 }
7008 resultobj = SWIG_Py_Void();
7009 return resultobj;
7010 fail:
7011 return NULL;
7012 }
7013
7014
7015 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7016 PyObject *resultobj = 0;
7017 wxRect *arg1 = (wxRect *) 0 ;
7018 int arg2 ;
7019 void *argp1 = 0 ;
7020 int res1 = 0 ;
7021 int val2 ;
7022 int ecode2 = 0 ;
7023 PyObject * obj0 = 0 ;
7024 PyObject * obj1 = 0 ;
7025 char * kwnames[] = {
7026 (char *) "self",(char *) "top", NULL
7027 };
7028
7029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7031 if (!SWIG_IsOK(res1)) {
7032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7033 }
7034 arg1 = reinterpret_cast< wxRect * >(argp1);
7035 ecode2 = SWIG_AsVal_int(obj1, &val2);
7036 if (!SWIG_IsOK(ecode2)) {
7037 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7038 }
7039 arg2 = static_cast< int >(val2);
7040 {
7041 PyThreadState* __tstate = wxPyBeginAllowThreads();
7042 (arg1)->SetTop(arg2);
7043 wxPyEndAllowThreads(__tstate);
7044 if (PyErr_Occurred()) SWIG_fail;
7045 }
7046 resultobj = SWIG_Py_Void();
7047 return resultobj;
7048 fail:
7049 return NULL;
7050 }
7051
7052
7053 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7054 PyObject *resultobj = 0;
7055 wxRect *arg1 = (wxRect *) 0 ;
7056 int arg2 ;
7057 void *argp1 = 0 ;
7058 int res1 = 0 ;
7059 int val2 ;
7060 int ecode2 = 0 ;
7061 PyObject * obj0 = 0 ;
7062 PyObject * obj1 = 0 ;
7063 char * kwnames[] = {
7064 (char *) "self",(char *) "bottom", NULL
7065 };
7066
7067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7069 if (!SWIG_IsOK(res1)) {
7070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7071 }
7072 arg1 = reinterpret_cast< wxRect * >(argp1);
7073 ecode2 = SWIG_AsVal_int(obj1, &val2);
7074 if (!SWIG_IsOK(ecode2)) {
7075 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7076 }
7077 arg2 = static_cast< int >(val2);
7078 {
7079 PyThreadState* __tstate = wxPyBeginAllowThreads();
7080 (arg1)->SetBottom(arg2);
7081 wxPyEndAllowThreads(__tstate);
7082 if (PyErr_Occurred()) SWIG_fail;
7083 }
7084 resultobj = SWIG_Py_Void();
7085 return resultobj;
7086 fail:
7087 return NULL;
7088 }
7089
7090
7091 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7092 PyObject *resultobj = 0;
7093 wxRect *arg1 = (wxRect *) 0 ;
7094 int arg2 ;
7095 int arg3 ;
7096 wxRect *result = 0 ;
7097 void *argp1 = 0 ;
7098 int res1 = 0 ;
7099 int val2 ;
7100 int ecode2 = 0 ;
7101 int val3 ;
7102 int ecode3 = 0 ;
7103 PyObject * obj0 = 0 ;
7104 PyObject * obj1 = 0 ;
7105 PyObject * obj2 = 0 ;
7106 char * kwnames[] = {
7107 (char *) "self",(char *) "dx",(char *) "dy", NULL
7108 };
7109
7110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7112 if (!SWIG_IsOK(res1)) {
7113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7114 }
7115 arg1 = reinterpret_cast< wxRect * >(argp1);
7116 ecode2 = SWIG_AsVal_int(obj1, &val2);
7117 if (!SWIG_IsOK(ecode2)) {
7118 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7119 }
7120 arg2 = static_cast< int >(val2);
7121 ecode3 = SWIG_AsVal_int(obj2, &val3);
7122 if (!SWIG_IsOK(ecode3)) {
7123 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7124 }
7125 arg3 = static_cast< int >(val3);
7126 {
7127 PyThreadState* __tstate = wxPyBeginAllowThreads();
7128 {
7129 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7130 result = (wxRect *) &_result_ref;
7131 }
7132 wxPyEndAllowThreads(__tstate);
7133 if (PyErr_Occurred()) SWIG_fail;
7134 }
7135 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7136 return resultobj;
7137 fail:
7138 return NULL;
7139 }
7140
7141
7142 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7143 PyObject *resultobj = 0;
7144 wxRect *arg1 = (wxRect *) 0 ;
7145 int arg2 ;
7146 int arg3 ;
7147 wxRect *result = 0 ;
7148 void *argp1 = 0 ;
7149 int res1 = 0 ;
7150 int val2 ;
7151 int ecode2 = 0 ;
7152 int val3 ;
7153 int ecode3 = 0 ;
7154 PyObject * obj0 = 0 ;
7155 PyObject * obj1 = 0 ;
7156 PyObject * obj2 = 0 ;
7157 char * kwnames[] = {
7158 (char *) "self",(char *) "dx",(char *) "dy", NULL
7159 };
7160
7161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7163 if (!SWIG_IsOK(res1)) {
7164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7165 }
7166 arg1 = reinterpret_cast< wxRect * >(argp1);
7167 ecode2 = SWIG_AsVal_int(obj1, &val2);
7168 if (!SWIG_IsOK(ecode2)) {
7169 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7170 }
7171 arg2 = static_cast< int >(val2);
7172 ecode3 = SWIG_AsVal_int(obj2, &val3);
7173 if (!SWIG_IsOK(ecode3)) {
7174 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7175 }
7176 arg3 = static_cast< int >(val3);
7177 {
7178 PyThreadState* __tstate = wxPyBeginAllowThreads();
7179 {
7180 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7181 result = (wxRect *) &_result_ref;
7182 }
7183 wxPyEndAllowThreads(__tstate);
7184 if (PyErr_Occurred()) SWIG_fail;
7185 }
7186 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7187 return resultobj;
7188 fail:
7189 return NULL;
7190 }
7191
7192
7193 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7194 PyObject *resultobj = 0;
7195 wxRect *arg1 = (wxRect *) 0 ;
7196 int arg2 ;
7197 int arg3 ;
7198 void *argp1 = 0 ;
7199 int res1 = 0 ;
7200 int val2 ;
7201 int ecode2 = 0 ;
7202 int val3 ;
7203 int ecode3 = 0 ;
7204 PyObject * obj0 = 0 ;
7205 PyObject * obj1 = 0 ;
7206 PyObject * obj2 = 0 ;
7207 char * kwnames[] = {
7208 (char *) "self",(char *) "dx",(char *) "dy", NULL
7209 };
7210
7211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7213 if (!SWIG_IsOK(res1)) {
7214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7215 }
7216 arg1 = reinterpret_cast< wxRect * >(argp1);
7217 ecode2 = SWIG_AsVal_int(obj1, &val2);
7218 if (!SWIG_IsOK(ecode2)) {
7219 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7220 }
7221 arg2 = static_cast< int >(val2);
7222 ecode3 = SWIG_AsVal_int(obj2, &val3);
7223 if (!SWIG_IsOK(ecode3)) {
7224 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7225 }
7226 arg3 = static_cast< int >(val3);
7227 {
7228 PyThreadState* __tstate = wxPyBeginAllowThreads();
7229 (arg1)->Offset(arg2,arg3);
7230 wxPyEndAllowThreads(__tstate);
7231 if (PyErr_Occurred()) SWIG_fail;
7232 }
7233 resultobj = SWIG_Py_Void();
7234 return resultobj;
7235 fail:
7236 return NULL;
7237 }
7238
7239
7240 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7241 PyObject *resultobj = 0;
7242 wxRect *arg1 = (wxRect *) 0 ;
7243 wxPoint *arg2 = 0 ;
7244 void *argp1 = 0 ;
7245 int res1 = 0 ;
7246 wxPoint temp2 ;
7247 PyObject * obj0 = 0 ;
7248 PyObject * obj1 = 0 ;
7249 char * kwnames[] = {
7250 (char *) "self",(char *) "pt", NULL
7251 };
7252
7253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7255 if (!SWIG_IsOK(res1)) {
7256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7257 }
7258 arg1 = reinterpret_cast< wxRect * >(argp1);
7259 {
7260 arg2 = &temp2;
7261 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7262 }
7263 {
7264 PyThreadState* __tstate = wxPyBeginAllowThreads();
7265 (arg1)->Offset((wxPoint const &)*arg2);
7266 wxPyEndAllowThreads(__tstate);
7267 if (PyErr_Occurred()) SWIG_fail;
7268 }
7269 resultobj = SWIG_Py_Void();
7270 return resultobj;
7271 fail:
7272 return NULL;
7273 }
7274
7275
7276 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7277 PyObject *resultobj = 0;
7278 wxRect *arg1 = (wxRect *) 0 ;
7279 wxRect *arg2 = 0 ;
7280 wxRect result;
7281 void *argp1 = 0 ;
7282 int res1 = 0 ;
7283 wxRect temp2 ;
7284 PyObject * obj0 = 0 ;
7285 PyObject * obj1 = 0 ;
7286 char * kwnames[] = {
7287 (char *) "self",(char *) "rect", NULL
7288 };
7289
7290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7292 if (!SWIG_IsOK(res1)) {
7293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7294 }
7295 arg1 = reinterpret_cast< wxRect * >(argp1);
7296 {
7297 arg2 = &temp2;
7298 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7299 }
7300 {
7301 PyThreadState* __tstate = wxPyBeginAllowThreads();
7302 result = (arg1)->Intersect((wxRect const &)*arg2);
7303 wxPyEndAllowThreads(__tstate);
7304 if (PyErr_Occurred()) SWIG_fail;
7305 }
7306 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7307 return resultobj;
7308 fail:
7309 return NULL;
7310 }
7311
7312
7313 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7314 PyObject *resultobj = 0;
7315 wxRect *arg1 = (wxRect *) 0 ;
7316 wxRect *arg2 = 0 ;
7317 wxRect result;
7318 void *argp1 = 0 ;
7319 int res1 = 0 ;
7320 wxRect temp2 ;
7321 PyObject * obj0 = 0 ;
7322 PyObject * obj1 = 0 ;
7323 char * kwnames[] = {
7324 (char *) "self",(char *) "rect", NULL
7325 };
7326
7327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7329 if (!SWIG_IsOK(res1)) {
7330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7331 }
7332 arg1 = reinterpret_cast< wxRect * >(argp1);
7333 {
7334 arg2 = &temp2;
7335 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7336 }
7337 {
7338 PyThreadState* __tstate = wxPyBeginAllowThreads();
7339 result = (arg1)->Union((wxRect const &)*arg2);
7340 wxPyEndAllowThreads(__tstate);
7341 if (PyErr_Occurred()) SWIG_fail;
7342 }
7343 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7344 return resultobj;
7345 fail:
7346 return NULL;
7347 }
7348
7349
7350 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7351 PyObject *resultobj = 0;
7352 wxRect *arg1 = (wxRect *) 0 ;
7353 wxRect *arg2 = 0 ;
7354 wxRect result;
7355 void *argp1 = 0 ;
7356 int res1 = 0 ;
7357 wxRect temp2 ;
7358 PyObject * obj0 = 0 ;
7359 PyObject * obj1 = 0 ;
7360 char * kwnames[] = {
7361 (char *) "self",(char *) "rect", NULL
7362 };
7363
7364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7366 if (!SWIG_IsOK(res1)) {
7367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7368 }
7369 arg1 = reinterpret_cast< wxRect * >(argp1);
7370 {
7371 arg2 = &temp2;
7372 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7373 }
7374 {
7375 PyThreadState* __tstate = wxPyBeginAllowThreads();
7376 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7377 wxPyEndAllowThreads(__tstate);
7378 if (PyErr_Occurred()) SWIG_fail;
7379 }
7380 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7381 return resultobj;
7382 fail:
7383 return NULL;
7384 }
7385
7386
7387 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7388 PyObject *resultobj = 0;
7389 wxRect *arg1 = (wxRect *) 0 ;
7390 wxRect *arg2 = 0 ;
7391 wxRect *result = 0 ;
7392 void *argp1 = 0 ;
7393 int res1 = 0 ;
7394 wxRect temp2 ;
7395 PyObject * obj0 = 0 ;
7396 PyObject * obj1 = 0 ;
7397 char * kwnames[] = {
7398 (char *) "self",(char *) "rect", NULL
7399 };
7400
7401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7403 if (!SWIG_IsOK(res1)) {
7404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7405 }
7406 arg1 = reinterpret_cast< wxRect * >(argp1);
7407 {
7408 arg2 = &temp2;
7409 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7410 }
7411 {
7412 PyThreadState* __tstate = wxPyBeginAllowThreads();
7413 {
7414 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7415 result = (wxRect *) &_result_ref;
7416 }
7417 wxPyEndAllowThreads(__tstate);
7418 if (PyErr_Occurred()) SWIG_fail;
7419 }
7420 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7421 return resultobj;
7422 fail:
7423 return NULL;
7424 }
7425
7426
7427 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7428 PyObject *resultobj = 0;
7429 wxRect *arg1 = (wxRect *) 0 ;
7430 PyObject *arg2 = (PyObject *) 0 ;
7431 bool result;
7432 void *argp1 = 0 ;
7433 int res1 = 0 ;
7434 PyObject * obj0 = 0 ;
7435 PyObject * obj1 = 0 ;
7436 char * kwnames[] = {
7437 (char *) "self",(char *) "other", NULL
7438 };
7439
7440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7442 if (!SWIG_IsOK(res1)) {
7443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7444 }
7445 arg1 = reinterpret_cast< wxRect * >(argp1);
7446 arg2 = obj1;
7447 {
7448 result = (bool)wxRect___eq__(arg1,arg2);
7449 if (PyErr_Occurred()) SWIG_fail;
7450 }
7451 {
7452 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7453 }
7454 return resultobj;
7455 fail:
7456 return NULL;
7457 }
7458
7459
7460 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7461 PyObject *resultobj = 0;
7462 wxRect *arg1 = (wxRect *) 0 ;
7463 PyObject *arg2 = (PyObject *) 0 ;
7464 bool result;
7465 void *argp1 = 0 ;
7466 int res1 = 0 ;
7467 PyObject * obj0 = 0 ;
7468 PyObject * obj1 = 0 ;
7469 char * kwnames[] = {
7470 (char *) "self",(char *) "other", NULL
7471 };
7472
7473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7475 if (!SWIG_IsOK(res1)) {
7476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7477 }
7478 arg1 = reinterpret_cast< wxRect * >(argp1);
7479 arg2 = obj1;
7480 {
7481 result = (bool)wxRect___ne__(arg1,arg2);
7482 if (PyErr_Occurred()) SWIG_fail;
7483 }
7484 {
7485 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7486 }
7487 return resultobj;
7488 fail:
7489 return NULL;
7490 }
7491
7492
7493 SWIGINTERN PyObject *_wrap_Rect_InsideXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7494 PyObject *resultobj = 0;
7495 wxRect *arg1 = (wxRect *) 0 ;
7496 int arg2 ;
7497 int arg3 ;
7498 bool result;
7499 void *argp1 = 0 ;
7500 int res1 = 0 ;
7501 int val2 ;
7502 int ecode2 = 0 ;
7503 int val3 ;
7504 int ecode3 = 0 ;
7505 PyObject * obj0 = 0 ;
7506 PyObject * obj1 = 0 ;
7507 PyObject * obj2 = 0 ;
7508 char * kwnames[] = {
7509 (char *) "self",(char *) "x",(char *) "y", NULL
7510 };
7511
7512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7514 if (!SWIG_IsOK(res1)) {
7515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7516 }
7517 arg1 = reinterpret_cast< wxRect * >(argp1);
7518 ecode2 = SWIG_AsVal_int(obj1, &val2);
7519 if (!SWIG_IsOK(ecode2)) {
7520 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_InsideXY" "', expected argument " "2"" of type '" "int""'");
7521 }
7522 arg2 = static_cast< int >(val2);
7523 ecode3 = SWIG_AsVal_int(obj2, &val3);
7524 if (!SWIG_IsOK(ecode3)) {
7525 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_InsideXY" "', expected argument " "3"" of type '" "int""'");
7526 }
7527 arg3 = static_cast< int >(val3);
7528 {
7529 PyThreadState* __tstate = wxPyBeginAllowThreads();
7530 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
7531 wxPyEndAllowThreads(__tstate);
7532 if (PyErr_Occurred()) SWIG_fail;
7533 }
7534 {
7535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7536 }
7537 return resultobj;
7538 fail:
7539 return NULL;
7540 }
7541
7542
7543 SWIGINTERN PyObject *_wrap_Rect_Inside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7544 PyObject *resultobj = 0;
7545 wxRect *arg1 = (wxRect *) 0 ;
7546 wxPoint *arg2 = 0 ;
7547 bool result;
7548 void *argp1 = 0 ;
7549 int res1 = 0 ;
7550 wxPoint temp2 ;
7551 PyObject * obj0 = 0 ;
7552 PyObject * obj1 = 0 ;
7553 char * kwnames[] = {
7554 (char *) "self",(char *) "pt", NULL
7555 };
7556
7557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) SWIG_fail;
7558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7559 if (!SWIG_IsOK(res1)) {
7560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inside" "', expected argument " "1"" of type '" "wxRect const *""'");
7561 }
7562 arg1 = reinterpret_cast< wxRect * >(argp1);
7563 {
7564 arg2 = &temp2;
7565 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7566 }
7567 {
7568 PyThreadState* __tstate = wxPyBeginAllowThreads();
7569 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
7570 wxPyEndAllowThreads(__tstate);
7571 if (PyErr_Occurred()) SWIG_fail;
7572 }
7573 {
7574 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7575 }
7576 return resultobj;
7577 fail:
7578 return NULL;
7579 }
7580
7581
7582 SWIGINTERN PyObject *_wrap_Rect_InsideRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7583 PyObject *resultobj = 0;
7584 wxRect *arg1 = (wxRect *) 0 ;
7585 wxRect *arg2 = 0 ;
7586 bool result;
7587 void *argp1 = 0 ;
7588 int res1 = 0 ;
7589 wxRect temp2 ;
7590 PyObject * obj0 = 0 ;
7591 PyObject * obj1 = 0 ;
7592 char * kwnames[] = {
7593 (char *) "self",(char *) "rect", NULL
7594 };
7595
7596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_InsideRect",kwnames,&obj0,&obj1)) SWIG_fail;
7597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7598 if (!SWIG_IsOK(res1)) {
7599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideRect" "', expected argument " "1"" of type '" "wxRect const *""'");
7600 }
7601 arg1 = reinterpret_cast< wxRect * >(argp1);
7602 {
7603 arg2 = &temp2;
7604 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7605 }
7606 {
7607 PyThreadState* __tstate = wxPyBeginAllowThreads();
7608 result = (bool)((wxRect const *)arg1)->Inside((wxRect const &)*arg2);
7609 wxPyEndAllowThreads(__tstate);
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_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7622 PyObject *resultobj = 0;
7623 wxRect *arg1 = (wxRect *) 0 ;
7624 wxRect *arg2 = 0 ;
7625 bool result;
7626 void *argp1 = 0 ;
7627 int res1 = 0 ;
7628 wxRect temp2 ;
7629 PyObject * obj0 = 0 ;
7630 PyObject * obj1 = 0 ;
7631 char * kwnames[] = {
7632 (char *) "self",(char *) "rect", NULL
7633 };
7634
7635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7637 if (!SWIG_IsOK(res1)) {
7638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7639 }
7640 arg1 = reinterpret_cast< wxRect * >(argp1);
7641 {
7642 arg2 = &temp2;
7643 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7644 }
7645 {
7646 PyThreadState* __tstate = wxPyBeginAllowThreads();
7647 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7648 wxPyEndAllowThreads(__tstate);
7649 if (PyErr_Occurred()) SWIG_fail;
7650 }
7651 {
7652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7653 }
7654 return resultobj;
7655 fail:
7656 return NULL;
7657 }
7658
7659
7660 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7661 PyObject *resultobj = 0;
7662 wxRect *arg1 = (wxRect *) 0 ;
7663 wxRect *arg2 = 0 ;
7664 int arg3 = (int) wxBOTH ;
7665 wxRect result;
7666 void *argp1 = 0 ;
7667 int res1 = 0 ;
7668 wxRect temp2 ;
7669 int val3 ;
7670 int ecode3 = 0 ;
7671 PyObject * obj0 = 0 ;
7672 PyObject * obj1 = 0 ;
7673 PyObject * obj2 = 0 ;
7674 char * kwnames[] = {
7675 (char *) "self",(char *) "r",(char *) "dir", NULL
7676 };
7677
7678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7680 if (!SWIG_IsOK(res1)) {
7681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7682 }
7683 arg1 = reinterpret_cast< wxRect * >(argp1);
7684 {
7685 arg2 = &temp2;
7686 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7687 }
7688 if (obj2) {
7689 ecode3 = SWIG_AsVal_int(obj2, &val3);
7690 if (!SWIG_IsOK(ecode3)) {
7691 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7692 }
7693 arg3 = static_cast< int >(val3);
7694 }
7695 {
7696 PyThreadState* __tstate = wxPyBeginAllowThreads();
7697 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7698 wxPyEndAllowThreads(__tstate);
7699 if (PyErr_Occurred()) SWIG_fail;
7700 }
7701 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7702 return resultobj;
7703 fail:
7704 return NULL;
7705 }
7706
7707
7708 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7709 PyObject *resultobj = 0;
7710 wxRect *arg1 = (wxRect *) 0 ;
7711 int arg2 ;
7712 void *argp1 = 0 ;
7713 int res1 = 0 ;
7714 int val2 ;
7715 int ecode2 = 0 ;
7716 PyObject *swig_obj[2] ;
7717
7718 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7720 if (!SWIG_IsOK(res1)) {
7721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7722 }
7723 arg1 = reinterpret_cast< wxRect * >(argp1);
7724 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7725 if (!SWIG_IsOK(ecode2)) {
7726 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7727 }
7728 arg2 = static_cast< int >(val2);
7729 if (arg1) (arg1)->x = arg2;
7730
7731 resultobj = SWIG_Py_Void();
7732 return resultobj;
7733 fail:
7734 return NULL;
7735 }
7736
7737
7738 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7739 PyObject *resultobj = 0;
7740 wxRect *arg1 = (wxRect *) 0 ;
7741 int result;
7742 void *argp1 = 0 ;
7743 int res1 = 0 ;
7744 PyObject *swig_obj[1] ;
7745
7746 if (!args) SWIG_fail;
7747 swig_obj[0] = args;
7748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7749 if (!SWIG_IsOK(res1)) {
7750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7751 }
7752 arg1 = reinterpret_cast< wxRect * >(argp1);
7753 result = (int) ((arg1)->x);
7754 resultobj = SWIG_From_int(static_cast< int >(result));
7755 return resultobj;
7756 fail:
7757 return NULL;
7758 }
7759
7760
7761 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7762 PyObject *resultobj = 0;
7763 wxRect *arg1 = (wxRect *) 0 ;
7764 int arg2 ;
7765 void *argp1 = 0 ;
7766 int res1 = 0 ;
7767 int val2 ;
7768 int ecode2 = 0 ;
7769 PyObject *swig_obj[2] ;
7770
7771 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7773 if (!SWIG_IsOK(res1)) {
7774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7775 }
7776 arg1 = reinterpret_cast< wxRect * >(argp1);
7777 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7778 if (!SWIG_IsOK(ecode2)) {
7779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7780 }
7781 arg2 = static_cast< int >(val2);
7782 if (arg1) (arg1)->y = arg2;
7783
7784 resultobj = SWIG_Py_Void();
7785 return resultobj;
7786 fail:
7787 return NULL;
7788 }
7789
7790
7791 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7792 PyObject *resultobj = 0;
7793 wxRect *arg1 = (wxRect *) 0 ;
7794 int result;
7795 void *argp1 = 0 ;
7796 int res1 = 0 ;
7797 PyObject *swig_obj[1] ;
7798
7799 if (!args) SWIG_fail;
7800 swig_obj[0] = args;
7801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7802 if (!SWIG_IsOK(res1)) {
7803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7804 }
7805 arg1 = reinterpret_cast< wxRect * >(argp1);
7806 result = (int) ((arg1)->y);
7807 resultobj = SWIG_From_int(static_cast< int >(result));
7808 return resultobj;
7809 fail:
7810 return NULL;
7811 }
7812
7813
7814 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7815 PyObject *resultobj = 0;
7816 wxRect *arg1 = (wxRect *) 0 ;
7817 int arg2 ;
7818 void *argp1 = 0 ;
7819 int res1 = 0 ;
7820 int val2 ;
7821 int ecode2 = 0 ;
7822 PyObject *swig_obj[2] ;
7823
7824 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7826 if (!SWIG_IsOK(res1)) {
7827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7828 }
7829 arg1 = reinterpret_cast< wxRect * >(argp1);
7830 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7831 if (!SWIG_IsOK(ecode2)) {
7832 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7833 }
7834 arg2 = static_cast< int >(val2);
7835 if (arg1) (arg1)->width = arg2;
7836
7837 resultobj = SWIG_Py_Void();
7838 return resultobj;
7839 fail:
7840 return NULL;
7841 }
7842
7843
7844 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7845 PyObject *resultobj = 0;
7846 wxRect *arg1 = (wxRect *) 0 ;
7847 int result;
7848 void *argp1 = 0 ;
7849 int res1 = 0 ;
7850 PyObject *swig_obj[1] ;
7851
7852 if (!args) SWIG_fail;
7853 swig_obj[0] = args;
7854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7855 if (!SWIG_IsOK(res1)) {
7856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7857 }
7858 arg1 = reinterpret_cast< wxRect * >(argp1);
7859 result = (int) ((arg1)->width);
7860 resultobj = SWIG_From_int(static_cast< int >(result));
7861 return resultobj;
7862 fail:
7863 return NULL;
7864 }
7865
7866
7867 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7868 PyObject *resultobj = 0;
7869 wxRect *arg1 = (wxRect *) 0 ;
7870 int arg2 ;
7871 void *argp1 = 0 ;
7872 int res1 = 0 ;
7873 int val2 ;
7874 int ecode2 = 0 ;
7875 PyObject *swig_obj[2] ;
7876
7877 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
7878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7879 if (!SWIG_IsOK(res1)) {
7880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
7881 }
7882 arg1 = reinterpret_cast< wxRect * >(argp1);
7883 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7884 if (!SWIG_IsOK(ecode2)) {
7885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
7886 }
7887 arg2 = static_cast< int >(val2);
7888 if (arg1) (arg1)->height = arg2;
7889
7890 resultobj = SWIG_Py_Void();
7891 return resultobj;
7892 fail:
7893 return NULL;
7894 }
7895
7896
7897 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7898 PyObject *resultobj = 0;
7899 wxRect *arg1 = (wxRect *) 0 ;
7900 int result;
7901 void *argp1 = 0 ;
7902 int res1 = 0 ;
7903 PyObject *swig_obj[1] ;
7904
7905 if (!args) SWIG_fail;
7906 swig_obj[0] = args;
7907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7908 if (!SWIG_IsOK(res1)) {
7909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
7910 }
7911 arg1 = reinterpret_cast< wxRect * >(argp1);
7912 result = (int) ((arg1)->height);
7913 resultobj = SWIG_From_int(static_cast< int >(result));
7914 return resultobj;
7915 fail:
7916 return NULL;
7917 }
7918
7919
7920 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7921 PyObject *resultobj = 0;
7922 wxRect *arg1 = (wxRect *) 0 ;
7923 int arg2 = (int) 0 ;
7924 int arg3 = (int) 0 ;
7925 int arg4 = (int) 0 ;
7926 int arg5 = (int) 0 ;
7927 void *argp1 = 0 ;
7928 int res1 = 0 ;
7929 int val2 ;
7930 int ecode2 = 0 ;
7931 int val3 ;
7932 int ecode3 = 0 ;
7933 int val4 ;
7934 int ecode4 = 0 ;
7935 int val5 ;
7936 int ecode5 = 0 ;
7937 PyObject * obj0 = 0 ;
7938 PyObject * obj1 = 0 ;
7939 PyObject * obj2 = 0 ;
7940 PyObject * obj3 = 0 ;
7941 PyObject * obj4 = 0 ;
7942 char * kwnames[] = {
7943 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7944 };
7945
7946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7948 if (!SWIG_IsOK(res1)) {
7949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
7950 }
7951 arg1 = reinterpret_cast< wxRect * >(argp1);
7952 if (obj1) {
7953 ecode2 = SWIG_AsVal_int(obj1, &val2);
7954 if (!SWIG_IsOK(ecode2)) {
7955 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
7956 }
7957 arg2 = static_cast< int >(val2);
7958 }
7959 if (obj2) {
7960 ecode3 = SWIG_AsVal_int(obj2, &val3);
7961 if (!SWIG_IsOK(ecode3)) {
7962 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
7963 }
7964 arg3 = static_cast< int >(val3);
7965 }
7966 if (obj3) {
7967 ecode4 = SWIG_AsVal_int(obj3, &val4);
7968 if (!SWIG_IsOK(ecode4)) {
7969 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
7970 }
7971 arg4 = static_cast< int >(val4);
7972 }
7973 if (obj4) {
7974 ecode5 = SWIG_AsVal_int(obj4, &val5);
7975 if (!SWIG_IsOK(ecode5)) {
7976 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
7977 }
7978 arg5 = static_cast< int >(val5);
7979 }
7980 {
7981 PyThreadState* __tstate = wxPyBeginAllowThreads();
7982 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
7983 wxPyEndAllowThreads(__tstate);
7984 if (PyErr_Occurred()) SWIG_fail;
7985 }
7986 resultobj = SWIG_Py_Void();
7987 return resultobj;
7988 fail:
7989 return NULL;
7990 }
7991
7992
7993 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7994 PyObject *resultobj = 0;
7995 wxRect *arg1 = (wxRect *) 0 ;
7996 PyObject *result = 0 ;
7997 void *argp1 = 0 ;
7998 int res1 = 0 ;
7999 PyObject *swig_obj[1] ;
8000
8001 if (!args) SWIG_fail;
8002 swig_obj[0] = args;
8003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8004 if (!SWIG_IsOK(res1)) {
8005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
8006 }
8007 arg1 = reinterpret_cast< wxRect * >(argp1);
8008 {
8009 PyThreadState* __tstate = wxPyBeginAllowThreads();
8010 result = (PyObject *)wxRect_Get(arg1);
8011 wxPyEndAllowThreads(__tstate);
8012 if (PyErr_Occurred()) SWIG_fail;
8013 }
8014 resultobj = result;
8015 return resultobj;
8016 fail:
8017 return NULL;
8018 }
8019
8020
8021 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8022 PyObject *obj;
8023 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8024 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
8025 return SWIG_Py_Void();
8026 }
8027
8028 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8029 return SWIG_Python_InitShadowInstance(args);
8030 }
8031
8032 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8033 PyObject *resultobj = 0;
8034 wxRect *arg1 = (wxRect *) 0 ;
8035 wxRect *arg2 = (wxRect *) 0 ;
8036 PyObject *result = 0 ;
8037 void *argp1 = 0 ;
8038 int res1 = 0 ;
8039 void *argp2 = 0 ;
8040 int res2 = 0 ;
8041 PyObject * obj0 = 0 ;
8042 PyObject * obj1 = 0 ;
8043 char * kwnames[] = {
8044 (char *) "r1",(char *) "r2", NULL
8045 };
8046
8047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
8048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8049 if (!SWIG_IsOK(res1)) {
8050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
8051 }
8052 arg1 = reinterpret_cast< wxRect * >(argp1);
8053 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
8054 if (!SWIG_IsOK(res2)) {
8055 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
8056 }
8057 arg2 = reinterpret_cast< wxRect * >(argp2);
8058 {
8059 if (!wxPyCheckForApp()) SWIG_fail;
8060 PyThreadState* __tstate = wxPyBeginAllowThreads();
8061 result = (PyObject *)wxIntersectRect(arg1,arg2);
8062 wxPyEndAllowThreads(__tstate);
8063 if (PyErr_Occurred()) SWIG_fail;
8064 }
8065 resultobj = result;
8066 return resultobj;
8067 fail:
8068 return NULL;
8069 }
8070
8071
8072 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8073 PyObject *resultobj = 0;
8074 double arg1 = (double) 0.0 ;
8075 double arg2 = (double) 0.0 ;
8076 wxPoint2D *result = 0 ;
8077 double val1 ;
8078 int ecode1 = 0 ;
8079 double val2 ;
8080 int ecode2 = 0 ;
8081 PyObject * obj0 = 0 ;
8082 PyObject * obj1 = 0 ;
8083 char * kwnames[] = {
8084 (char *) "x",(char *) "y", NULL
8085 };
8086
8087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8088 if (obj0) {
8089 ecode1 = SWIG_AsVal_double(obj0, &val1);
8090 if (!SWIG_IsOK(ecode1)) {
8091 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8092 }
8093 arg1 = static_cast< double >(val1);
8094 }
8095 if (obj1) {
8096 ecode2 = SWIG_AsVal_double(obj1, &val2);
8097 if (!SWIG_IsOK(ecode2)) {
8098 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8099 }
8100 arg2 = static_cast< double >(val2);
8101 }
8102 {
8103 PyThreadState* __tstate = wxPyBeginAllowThreads();
8104 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8105 wxPyEndAllowThreads(__tstate);
8106 if (PyErr_Occurred()) SWIG_fail;
8107 }
8108 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8109 return resultobj;
8110 fail:
8111 return NULL;
8112 }
8113
8114
8115 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8116 PyObject *resultobj = 0;
8117 wxPoint2D *arg1 = 0 ;
8118 wxPoint2D *result = 0 ;
8119 wxPoint2D temp1 ;
8120 PyObject * obj0 = 0 ;
8121 char * kwnames[] = {
8122 (char *) "pt", NULL
8123 };
8124
8125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8126 {
8127 arg1 = &temp1;
8128 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8129 }
8130 {
8131 PyThreadState* __tstate = wxPyBeginAllowThreads();
8132 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8133 wxPyEndAllowThreads(__tstate);
8134 if (PyErr_Occurred()) SWIG_fail;
8135 }
8136 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8137 return resultobj;
8138 fail:
8139 return NULL;
8140 }
8141
8142
8143 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8144 PyObject *resultobj = 0;
8145 wxPoint *arg1 = 0 ;
8146 wxPoint2D *result = 0 ;
8147 wxPoint temp1 ;
8148 PyObject * obj0 = 0 ;
8149 char * kwnames[] = {
8150 (char *) "pt", NULL
8151 };
8152
8153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8154 {
8155 arg1 = &temp1;
8156 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8157 }
8158 {
8159 PyThreadState* __tstate = wxPyBeginAllowThreads();
8160 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8161 wxPyEndAllowThreads(__tstate);
8162 if (PyErr_Occurred()) SWIG_fail;
8163 }
8164 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8165 return resultobj;
8166 fail:
8167 return NULL;
8168 }
8169
8170
8171 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8172 PyObject *resultobj = 0;
8173 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8174 int *arg2 = (int *) 0 ;
8175 int *arg3 = (int *) 0 ;
8176 void *argp1 = 0 ;
8177 int res1 = 0 ;
8178 int temp2 ;
8179 int res2 = SWIG_TMPOBJ ;
8180 int temp3 ;
8181 int res3 = SWIG_TMPOBJ ;
8182 PyObject *swig_obj[1] ;
8183
8184 arg2 = &temp2;
8185 arg3 = &temp3;
8186 if (!args) SWIG_fail;
8187 swig_obj[0] = args;
8188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8189 if (!SWIG_IsOK(res1)) {
8190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8191 }
8192 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8193 {
8194 PyThreadState* __tstate = wxPyBeginAllowThreads();
8195 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8196 wxPyEndAllowThreads(__tstate);
8197 if (PyErr_Occurred()) SWIG_fail;
8198 }
8199 resultobj = SWIG_Py_Void();
8200 if (SWIG_IsTmpObj(res2)) {
8201 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8202 } else {
8203 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8204 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8205 }
8206 if (SWIG_IsTmpObj(res3)) {
8207 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8208 } else {
8209 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8210 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8211 }
8212 return resultobj;
8213 fail:
8214 return NULL;
8215 }
8216
8217
8218 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8219 PyObject *resultobj = 0;
8220 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8221 int *arg2 = (int *) 0 ;
8222 int *arg3 = (int *) 0 ;
8223 void *argp1 = 0 ;
8224 int res1 = 0 ;
8225 int temp2 ;
8226 int res2 = SWIG_TMPOBJ ;
8227 int temp3 ;
8228 int res3 = SWIG_TMPOBJ ;
8229 PyObject *swig_obj[1] ;
8230
8231 arg2 = &temp2;
8232 arg3 = &temp3;
8233 if (!args) SWIG_fail;
8234 swig_obj[0] = args;
8235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8236 if (!SWIG_IsOK(res1)) {
8237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8238 }
8239 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8240 {
8241 PyThreadState* __tstate = wxPyBeginAllowThreads();
8242 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8243 wxPyEndAllowThreads(__tstate);
8244 if (PyErr_Occurred()) SWIG_fail;
8245 }
8246 resultobj = SWIG_Py_Void();
8247 if (SWIG_IsTmpObj(res2)) {
8248 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8249 } else {
8250 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8251 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8252 }
8253 if (SWIG_IsTmpObj(res3)) {
8254 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8255 } else {
8256 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8257 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8258 }
8259 return resultobj;
8260 fail:
8261 return NULL;
8262 }
8263
8264
8265 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8266 PyObject *resultobj = 0;
8267 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8268 double result;
8269 void *argp1 = 0 ;
8270 int res1 = 0 ;
8271 PyObject *swig_obj[1] ;
8272
8273 if (!args) SWIG_fail;
8274 swig_obj[0] = args;
8275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8276 if (!SWIG_IsOK(res1)) {
8277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8278 }
8279 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8280 {
8281 PyThreadState* __tstate = wxPyBeginAllowThreads();
8282 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8283 wxPyEndAllowThreads(__tstate);
8284 if (PyErr_Occurred()) SWIG_fail;
8285 }
8286 resultobj = SWIG_From_double(static_cast< double >(result));
8287 return resultobj;
8288 fail:
8289 return NULL;
8290 }
8291
8292
8293 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8294 PyObject *resultobj = 0;
8295 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8296 double result;
8297 void *argp1 = 0 ;
8298 int res1 = 0 ;
8299 PyObject *swig_obj[1] ;
8300
8301 if (!args) SWIG_fail;
8302 swig_obj[0] = args;
8303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8304 if (!SWIG_IsOK(res1)) {
8305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8306 }
8307 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8308 {
8309 PyThreadState* __tstate = wxPyBeginAllowThreads();
8310 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8311 wxPyEndAllowThreads(__tstate);
8312 if (PyErr_Occurred()) SWIG_fail;
8313 }
8314 resultobj = SWIG_From_double(static_cast< double >(result));
8315 return resultobj;
8316 fail:
8317 return NULL;
8318 }
8319
8320
8321 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8322 PyObject *resultobj = 0;
8323 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8324 double arg2 ;
8325 void *argp1 = 0 ;
8326 int res1 = 0 ;
8327 double val2 ;
8328 int ecode2 = 0 ;
8329 PyObject * obj0 = 0 ;
8330 PyObject * obj1 = 0 ;
8331 char * kwnames[] = {
8332 (char *) "self",(char *) "length", NULL
8333 };
8334
8335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8337 if (!SWIG_IsOK(res1)) {
8338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8339 }
8340 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8341 ecode2 = SWIG_AsVal_double(obj1, &val2);
8342 if (!SWIG_IsOK(ecode2)) {
8343 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8344 }
8345 arg2 = static_cast< double >(val2);
8346 {
8347 PyThreadState* __tstate = wxPyBeginAllowThreads();
8348 (arg1)->SetVectorLength(arg2);
8349 wxPyEndAllowThreads(__tstate);
8350 if (PyErr_Occurred()) SWIG_fail;
8351 }
8352 resultobj = SWIG_Py_Void();
8353 return resultobj;
8354 fail:
8355 return NULL;
8356 }
8357
8358
8359 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8360 PyObject *resultobj = 0;
8361 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8362 double arg2 ;
8363 void *argp1 = 0 ;
8364 int res1 = 0 ;
8365 double val2 ;
8366 int ecode2 = 0 ;
8367 PyObject * obj0 = 0 ;
8368 PyObject * obj1 = 0 ;
8369 char * kwnames[] = {
8370 (char *) "self",(char *) "degrees", NULL
8371 };
8372
8373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8375 if (!SWIG_IsOK(res1)) {
8376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8377 }
8378 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8379 ecode2 = SWIG_AsVal_double(obj1, &val2);
8380 if (!SWIG_IsOK(ecode2)) {
8381 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8382 }
8383 arg2 = static_cast< double >(val2);
8384 {
8385 PyThreadState* __tstate = wxPyBeginAllowThreads();
8386 (arg1)->SetVectorAngle(arg2);
8387 wxPyEndAllowThreads(__tstate);
8388 if (PyErr_Occurred()) SWIG_fail;
8389 }
8390 resultobj = SWIG_Py_Void();
8391 return resultobj;
8392 fail:
8393 return NULL;
8394 }
8395
8396
8397 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8398 PyObject *resultobj = 0;
8399 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8400 wxPoint2D *arg2 = 0 ;
8401 double result;
8402 void *argp1 = 0 ;
8403 int res1 = 0 ;
8404 wxPoint2D temp2 ;
8405 PyObject * obj0 = 0 ;
8406 PyObject * obj1 = 0 ;
8407 char * kwnames[] = {
8408 (char *) "self",(char *) "pt", NULL
8409 };
8410
8411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8413 if (!SWIG_IsOK(res1)) {
8414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8415 }
8416 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8417 {
8418 arg2 = &temp2;
8419 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8420 }
8421 {
8422 PyThreadState* __tstate = wxPyBeginAllowThreads();
8423 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8424 wxPyEndAllowThreads(__tstate);
8425 if (PyErr_Occurred()) SWIG_fail;
8426 }
8427 resultobj = SWIG_From_double(static_cast< double >(result));
8428 return resultobj;
8429 fail:
8430 return NULL;
8431 }
8432
8433
8434 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8435 PyObject *resultobj = 0;
8436 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8437 wxPoint2D *arg2 = 0 ;
8438 double result;
8439 void *argp1 = 0 ;
8440 int res1 = 0 ;
8441 wxPoint2D temp2 ;
8442 PyObject * obj0 = 0 ;
8443 PyObject * obj1 = 0 ;
8444 char * kwnames[] = {
8445 (char *) "self",(char *) "pt", NULL
8446 };
8447
8448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8450 if (!SWIG_IsOK(res1)) {
8451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8452 }
8453 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8454 {
8455 arg2 = &temp2;
8456 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8457 }
8458 {
8459 PyThreadState* __tstate = wxPyBeginAllowThreads();
8460 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8461 wxPyEndAllowThreads(__tstate);
8462 if (PyErr_Occurred()) SWIG_fail;
8463 }
8464 resultobj = SWIG_From_double(static_cast< double >(result));
8465 return resultobj;
8466 fail:
8467 return NULL;
8468 }
8469
8470
8471 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8472 PyObject *resultobj = 0;
8473 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8474 wxPoint2D *arg2 = 0 ;
8475 double result;
8476 void *argp1 = 0 ;
8477 int res1 = 0 ;
8478 wxPoint2D temp2 ;
8479 PyObject * obj0 = 0 ;
8480 PyObject * obj1 = 0 ;
8481 char * kwnames[] = {
8482 (char *) "self",(char *) "vec", NULL
8483 };
8484
8485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8487 if (!SWIG_IsOK(res1)) {
8488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8489 }
8490 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8491 {
8492 arg2 = &temp2;
8493 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8494 }
8495 {
8496 PyThreadState* __tstate = wxPyBeginAllowThreads();
8497 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8498 wxPyEndAllowThreads(__tstate);
8499 if (PyErr_Occurred()) SWIG_fail;
8500 }
8501 resultobj = SWIG_From_double(static_cast< double >(result));
8502 return resultobj;
8503 fail:
8504 return NULL;
8505 }
8506
8507
8508 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8509 PyObject *resultobj = 0;
8510 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8511 wxPoint2D *arg2 = 0 ;
8512 double result;
8513 void *argp1 = 0 ;
8514 int res1 = 0 ;
8515 wxPoint2D temp2 ;
8516 PyObject * obj0 = 0 ;
8517 PyObject * obj1 = 0 ;
8518 char * kwnames[] = {
8519 (char *) "self",(char *) "vec", NULL
8520 };
8521
8522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8524 if (!SWIG_IsOK(res1)) {
8525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8526 }
8527 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8528 {
8529 arg2 = &temp2;
8530 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8531 }
8532 {
8533 PyThreadState* __tstate = wxPyBeginAllowThreads();
8534 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8535 wxPyEndAllowThreads(__tstate);
8536 if (PyErr_Occurred()) SWIG_fail;
8537 }
8538 resultobj = SWIG_From_double(static_cast< double >(result));
8539 return resultobj;
8540 fail:
8541 return NULL;
8542 }
8543
8544
8545 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8546 PyObject *resultobj = 0;
8547 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8548 wxPoint2D result;
8549 void *argp1 = 0 ;
8550 int res1 = 0 ;
8551 PyObject *swig_obj[1] ;
8552
8553 if (!args) SWIG_fail;
8554 swig_obj[0] = args;
8555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8556 if (!SWIG_IsOK(res1)) {
8557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8558 }
8559 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8560 {
8561 PyThreadState* __tstate = wxPyBeginAllowThreads();
8562 result = (arg1)->operator -();
8563 wxPyEndAllowThreads(__tstate);
8564 if (PyErr_Occurred()) SWIG_fail;
8565 }
8566 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8567 return resultobj;
8568 fail:
8569 return NULL;
8570 }
8571
8572
8573 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8574 PyObject *resultobj = 0;
8575 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8576 wxPoint2D *arg2 = 0 ;
8577 wxPoint2D *result = 0 ;
8578 void *argp1 = 0 ;
8579 int res1 = 0 ;
8580 wxPoint2D temp2 ;
8581 PyObject * obj0 = 0 ;
8582 PyObject * obj1 = 0 ;
8583 char * kwnames[] = {
8584 (char *) "self",(char *) "pt", NULL
8585 };
8586
8587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8589 if (!SWIG_IsOK(res1)) {
8590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8591 }
8592 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8593 {
8594 arg2 = &temp2;
8595 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8596 }
8597 {
8598 PyThreadState* __tstate = wxPyBeginAllowThreads();
8599 {
8600 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8601 result = (wxPoint2D *) &_result_ref;
8602 }
8603 wxPyEndAllowThreads(__tstate);
8604 if (PyErr_Occurred()) SWIG_fail;
8605 }
8606 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8607 return resultobj;
8608 fail:
8609 return NULL;
8610 }
8611
8612
8613 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8614 PyObject *resultobj = 0;
8615 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8616 wxPoint2D *arg2 = 0 ;
8617 wxPoint2D *result = 0 ;
8618 void *argp1 = 0 ;
8619 int res1 = 0 ;
8620 wxPoint2D temp2 ;
8621 PyObject * obj0 = 0 ;
8622 PyObject * obj1 = 0 ;
8623 char * kwnames[] = {
8624 (char *) "self",(char *) "pt", NULL
8625 };
8626
8627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8629 if (!SWIG_IsOK(res1)) {
8630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8631 }
8632 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8633 {
8634 arg2 = &temp2;
8635 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8636 }
8637 {
8638 PyThreadState* __tstate = wxPyBeginAllowThreads();
8639 {
8640 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8641 result = (wxPoint2D *) &_result_ref;
8642 }
8643 wxPyEndAllowThreads(__tstate);
8644 if (PyErr_Occurred()) SWIG_fail;
8645 }
8646 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8647 return resultobj;
8648 fail:
8649 return NULL;
8650 }
8651
8652
8653 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8654 PyObject *resultobj = 0;
8655 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8656 wxPoint2D *arg2 = 0 ;
8657 wxPoint2D *result = 0 ;
8658 void *argp1 = 0 ;
8659 int res1 = 0 ;
8660 wxPoint2D temp2 ;
8661 PyObject * obj0 = 0 ;
8662 PyObject * obj1 = 0 ;
8663 char * kwnames[] = {
8664 (char *) "self",(char *) "pt", NULL
8665 };
8666
8667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8669 if (!SWIG_IsOK(res1)) {
8670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8671 }
8672 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8673 {
8674 arg2 = &temp2;
8675 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8676 }
8677 {
8678 PyThreadState* __tstate = wxPyBeginAllowThreads();
8679 {
8680 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8681 result = (wxPoint2D *) &_result_ref;
8682 }
8683 wxPyEndAllowThreads(__tstate);
8684 if (PyErr_Occurred()) SWIG_fail;
8685 }
8686 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8687 return resultobj;
8688 fail:
8689 return NULL;
8690 }
8691
8692
8693 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8694 PyObject *resultobj = 0;
8695 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8696 wxPoint2D *arg2 = 0 ;
8697 wxPoint2D *result = 0 ;
8698 void *argp1 = 0 ;
8699 int res1 = 0 ;
8700 wxPoint2D temp2 ;
8701 PyObject * obj0 = 0 ;
8702 PyObject * obj1 = 0 ;
8703 char * kwnames[] = {
8704 (char *) "self",(char *) "pt", NULL
8705 };
8706
8707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8709 if (!SWIG_IsOK(res1)) {
8710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8711 }
8712 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8713 {
8714 arg2 = &temp2;
8715 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8716 }
8717 {
8718 PyThreadState* __tstate = wxPyBeginAllowThreads();
8719 {
8720 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8721 result = (wxPoint2D *) &_result_ref;
8722 }
8723 wxPyEndAllowThreads(__tstate);
8724 if (PyErr_Occurred()) SWIG_fail;
8725 }
8726 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8727 return resultobj;
8728 fail:
8729 return NULL;
8730 }
8731
8732
8733 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8734 PyObject *resultobj = 0;
8735 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8736 PyObject *arg2 = (PyObject *) 0 ;
8737 bool result;
8738 void *argp1 = 0 ;
8739 int res1 = 0 ;
8740 PyObject * obj0 = 0 ;
8741 PyObject * obj1 = 0 ;
8742 char * kwnames[] = {
8743 (char *) "self",(char *) "other", NULL
8744 };
8745
8746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8748 if (!SWIG_IsOK(res1)) {
8749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8750 }
8751 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8752 arg2 = obj1;
8753 {
8754 result = (bool)wxPoint2D___eq__(arg1,arg2);
8755 if (PyErr_Occurred()) SWIG_fail;
8756 }
8757 {
8758 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8759 }
8760 return resultobj;
8761 fail:
8762 return NULL;
8763 }
8764
8765
8766 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8767 PyObject *resultobj = 0;
8768 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8769 PyObject *arg2 = (PyObject *) 0 ;
8770 bool result;
8771 void *argp1 = 0 ;
8772 int res1 = 0 ;
8773 PyObject * obj0 = 0 ;
8774 PyObject * obj1 = 0 ;
8775 char * kwnames[] = {
8776 (char *) "self",(char *) "other", NULL
8777 };
8778
8779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8781 if (!SWIG_IsOK(res1)) {
8782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8783 }
8784 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8785 arg2 = obj1;
8786 {
8787 result = (bool)wxPoint2D___ne__(arg1,arg2);
8788 if (PyErr_Occurred()) SWIG_fail;
8789 }
8790 {
8791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8792 }
8793 return resultobj;
8794 fail:
8795 return NULL;
8796 }
8797
8798
8799 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8800 PyObject *resultobj = 0;
8801 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8802 double arg2 ;
8803 void *argp1 = 0 ;
8804 int res1 = 0 ;
8805 double val2 ;
8806 int ecode2 = 0 ;
8807 PyObject *swig_obj[2] ;
8808
8809 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8811 if (!SWIG_IsOK(res1)) {
8812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8813 }
8814 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8815 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8816 if (!SWIG_IsOK(ecode2)) {
8817 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8818 }
8819 arg2 = static_cast< double >(val2);
8820 if (arg1) (arg1)->m_x = arg2;
8821
8822 resultobj = SWIG_Py_Void();
8823 return resultobj;
8824 fail:
8825 return NULL;
8826 }
8827
8828
8829 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8830 PyObject *resultobj = 0;
8831 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8832 double result;
8833 void *argp1 = 0 ;
8834 int res1 = 0 ;
8835 PyObject *swig_obj[1] ;
8836
8837 if (!args) SWIG_fail;
8838 swig_obj[0] = args;
8839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8840 if (!SWIG_IsOK(res1)) {
8841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8842 }
8843 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8844 result = (double) ((arg1)->m_x);
8845 resultobj = SWIG_From_double(static_cast< double >(result));
8846 return resultobj;
8847 fail:
8848 return NULL;
8849 }
8850
8851
8852 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8853 PyObject *resultobj = 0;
8854 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8855 double arg2 ;
8856 void *argp1 = 0 ;
8857 int res1 = 0 ;
8858 double val2 ;
8859 int ecode2 = 0 ;
8860 PyObject *swig_obj[2] ;
8861
8862 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8864 if (!SWIG_IsOK(res1)) {
8865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8866 }
8867 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8868 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8869 if (!SWIG_IsOK(ecode2)) {
8870 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8871 }
8872 arg2 = static_cast< double >(val2);
8873 if (arg1) (arg1)->m_y = arg2;
8874
8875 resultobj = SWIG_Py_Void();
8876 return resultobj;
8877 fail:
8878 return NULL;
8879 }
8880
8881
8882 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8883 PyObject *resultobj = 0;
8884 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8885 double result;
8886 void *argp1 = 0 ;
8887 int res1 = 0 ;
8888 PyObject *swig_obj[1] ;
8889
8890 if (!args) SWIG_fail;
8891 swig_obj[0] = args;
8892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8893 if (!SWIG_IsOK(res1)) {
8894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8895 }
8896 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8897 result = (double) ((arg1)->m_y);
8898 resultobj = SWIG_From_double(static_cast< double >(result));
8899 return resultobj;
8900 fail:
8901 return NULL;
8902 }
8903
8904
8905 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8906 PyObject *resultobj = 0;
8907 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8908 double arg2 = (double) 0 ;
8909 double arg3 = (double) 0 ;
8910 void *argp1 = 0 ;
8911 int res1 = 0 ;
8912 double val2 ;
8913 int ecode2 = 0 ;
8914 double val3 ;
8915 int ecode3 = 0 ;
8916 PyObject * obj0 = 0 ;
8917 PyObject * obj1 = 0 ;
8918 PyObject * obj2 = 0 ;
8919 char * kwnames[] = {
8920 (char *) "self",(char *) "x",(char *) "y", NULL
8921 };
8922
8923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8925 if (!SWIG_IsOK(res1)) {
8926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8927 }
8928 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8929 if (obj1) {
8930 ecode2 = SWIG_AsVal_double(obj1, &val2);
8931 if (!SWIG_IsOK(ecode2)) {
8932 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
8933 }
8934 arg2 = static_cast< double >(val2);
8935 }
8936 if (obj2) {
8937 ecode3 = SWIG_AsVal_double(obj2, &val3);
8938 if (!SWIG_IsOK(ecode3)) {
8939 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
8940 }
8941 arg3 = static_cast< double >(val3);
8942 }
8943 {
8944 PyThreadState* __tstate = wxPyBeginAllowThreads();
8945 wxPoint2D_Set(arg1,arg2,arg3);
8946 wxPyEndAllowThreads(__tstate);
8947 if (PyErr_Occurred()) SWIG_fail;
8948 }
8949 resultobj = SWIG_Py_Void();
8950 return resultobj;
8951 fail:
8952 return NULL;
8953 }
8954
8955
8956 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8957 PyObject *resultobj = 0;
8958 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8959 PyObject *result = 0 ;
8960 void *argp1 = 0 ;
8961 int res1 = 0 ;
8962 PyObject *swig_obj[1] ;
8963
8964 if (!args) SWIG_fail;
8965 swig_obj[0] = args;
8966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8967 if (!SWIG_IsOK(res1)) {
8968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8969 }
8970 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8971 {
8972 PyThreadState* __tstate = wxPyBeginAllowThreads();
8973 result = (PyObject *)wxPoint2D_Get(arg1);
8974 wxPyEndAllowThreads(__tstate);
8975 if (PyErr_Occurred()) SWIG_fail;
8976 }
8977 resultobj = result;
8978 return resultobj;
8979 fail:
8980 return NULL;
8981 }
8982
8983
8984 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8985 PyObject *obj;
8986 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8987 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
8988 return SWIG_Py_Void();
8989 }
8990
8991 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8992 return SWIG_Python_InitShadowInstance(args);
8993 }
8994
8995 SWIGINTERN int DefaultPosition_set(PyObject *) {
8996 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
8997 return 1;
8998 }
8999
9000
9001 SWIGINTERN PyObject *DefaultPosition_get(void) {
9002 PyObject *pyobj = 0;
9003
9004 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
9005 return pyobj;
9006 }
9007
9008
9009 SWIGINTERN int DefaultSize_set(PyObject *) {
9010 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
9011 return 1;
9012 }
9013
9014
9015 SWIGINTERN PyObject *DefaultSize_get(void) {
9016 PyObject *pyobj = 0;
9017
9018 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
9019 return pyobj;
9020 }
9021
9022
9023 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9024 PyObject *resultobj = 0;
9025 PyObject *arg1 = (PyObject *) 0 ;
9026 wxPyInputStream *result = 0 ;
9027 PyObject * obj0 = 0 ;
9028 char * kwnames[] = {
9029 (char *) "p", NULL
9030 };
9031
9032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
9033 arg1 = obj0;
9034 {
9035 PyThreadState* __tstate = wxPyBeginAllowThreads();
9036 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
9037 wxPyEndAllowThreads(__tstate);
9038 if (PyErr_Occurred()) SWIG_fail;
9039 }
9040 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
9041 return resultobj;
9042 fail:
9043 return NULL;
9044 }
9045
9046
9047 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9048 PyObject *resultobj = 0;
9049 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9050 void *argp1 = 0 ;
9051 int res1 = 0 ;
9052 PyObject *swig_obj[1] ;
9053
9054 if (!args) SWIG_fail;
9055 swig_obj[0] = args;
9056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
9057 if (!SWIG_IsOK(res1)) {
9058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9059 }
9060 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9061 {
9062 PyThreadState* __tstate = wxPyBeginAllowThreads();
9063 delete arg1;
9064
9065 wxPyEndAllowThreads(__tstate);
9066 if (PyErr_Occurred()) SWIG_fail;
9067 }
9068 resultobj = SWIG_Py_Void();
9069 return resultobj;
9070 fail:
9071 return NULL;
9072 }
9073
9074
9075 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9076 PyObject *resultobj = 0;
9077 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9078 void *argp1 = 0 ;
9079 int res1 = 0 ;
9080 PyObject *swig_obj[1] ;
9081
9082 if (!args) SWIG_fail;
9083 swig_obj[0] = args;
9084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9085 if (!SWIG_IsOK(res1)) {
9086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9087 }
9088 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9089 {
9090 PyThreadState* __tstate = wxPyBeginAllowThreads();
9091 (arg1)->close();
9092 wxPyEndAllowThreads(__tstate);
9093 if (PyErr_Occurred()) SWIG_fail;
9094 }
9095 resultobj = SWIG_Py_Void();
9096 return resultobj;
9097 fail:
9098 return NULL;
9099 }
9100
9101
9102 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9103 PyObject *resultobj = 0;
9104 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9105 void *argp1 = 0 ;
9106 int res1 = 0 ;
9107 PyObject *swig_obj[1] ;
9108
9109 if (!args) SWIG_fail;
9110 swig_obj[0] = args;
9111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9112 if (!SWIG_IsOK(res1)) {
9113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9114 }
9115 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9116 {
9117 PyThreadState* __tstate = wxPyBeginAllowThreads();
9118 (arg1)->flush();
9119 wxPyEndAllowThreads(__tstate);
9120 if (PyErr_Occurred()) SWIG_fail;
9121 }
9122 resultobj = SWIG_Py_Void();
9123 return resultobj;
9124 fail:
9125 return NULL;
9126 }
9127
9128
9129 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9130 PyObject *resultobj = 0;
9131 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9132 bool result;
9133 void *argp1 = 0 ;
9134 int res1 = 0 ;
9135 PyObject *swig_obj[1] ;
9136
9137 if (!args) SWIG_fail;
9138 swig_obj[0] = args;
9139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9140 if (!SWIG_IsOK(res1)) {
9141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9142 }
9143 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9144 {
9145 PyThreadState* __tstate = wxPyBeginAllowThreads();
9146 result = (bool)(arg1)->eof();
9147 wxPyEndAllowThreads(__tstate);
9148 if (PyErr_Occurred()) SWIG_fail;
9149 }
9150 {
9151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9152 }
9153 return resultobj;
9154 fail:
9155 return NULL;
9156 }
9157
9158
9159 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9160 PyObject *resultobj = 0;
9161 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9162 int arg2 = (int) -1 ;
9163 PyObject *result = 0 ;
9164 void *argp1 = 0 ;
9165 int res1 = 0 ;
9166 int val2 ;
9167 int ecode2 = 0 ;
9168 PyObject * obj0 = 0 ;
9169 PyObject * obj1 = 0 ;
9170 char * kwnames[] = {
9171 (char *) "self",(char *) "size", NULL
9172 };
9173
9174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9176 if (!SWIG_IsOK(res1)) {
9177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9178 }
9179 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9180 if (obj1) {
9181 ecode2 = SWIG_AsVal_int(obj1, &val2);
9182 if (!SWIG_IsOK(ecode2)) {
9183 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9184 }
9185 arg2 = static_cast< int >(val2);
9186 }
9187 {
9188 PyThreadState* __tstate = wxPyBeginAllowThreads();
9189 result = (PyObject *)(arg1)->read(arg2);
9190 wxPyEndAllowThreads(__tstate);
9191 if (PyErr_Occurred()) SWIG_fail;
9192 }
9193 resultobj = result;
9194 return resultobj;
9195 fail:
9196 return NULL;
9197 }
9198
9199
9200 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9201 PyObject *resultobj = 0;
9202 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9203 int arg2 = (int) -1 ;
9204 PyObject *result = 0 ;
9205 void *argp1 = 0 ;
9206 int res1 = 0 ;
9207 int val2 ;
9208 int ecode2 = 0 ;
9209 PyObject * obj0 = 0 ;
9210 PyObject * obj1 = 0 ;
9211 char * kwnames[] = {
9212 (char *) "self",(char *) "size", NULL
9213 };
9214
9215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9217 if (!SWIG_IsOK(res1)) {
9218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9219 }
9220 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9221 if (obj1) {
9222 ecode2 = SWIG_AsVal_int(obj1, &val2);
9223 if (!SWIG_IsOK(ecode2)) {
9224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9225 }
9226 arg2 = static_cast< int >(val2);
9227 }
9228 {
9229 PyThreadState* __tstate = wxPyBeginAllowThreads();
9230 result = (PyObject *)(arg1)->readline(arg2);
9231 wxPyEndAllowThreads(__tstate);
9232 if (PyErr_Occurred()) SWIG_fail;
9233 }
9234 resultobj = result;
9235 return resultobj;
9236 fail:
9237 return NULL;
9238 }
9239
9240
9241 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9242 PyObject *resultobj = 0;
9243 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9244 int arg2 = (int) -1 ;
9245 PyObject *result = 0 ;
9246 void *argp1 = 0 ;
9247 int res1 = 0 ;
9248 int val2 ;
9249 int ecode2 = 0 ;
9250 PyObject * obj0 = 0 ;
9251 PyObject * obj1 = 0 ;
9252 char * kwnames[] = {
9253 (char *) "self",(char *) "sizehint", NULL
9254 };
9255
9256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9258 if (!SWIG_IsOK(res1)) {
9259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9260 }
9261 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9262 if (obj1) {
9263 ecode2 = SWIG_AsVal_int(obj1, &val2);
9264 if (!SWIG_IsOK(ecode2)) {
9265 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9266 }
9267 arg2 = static_cast< int >(val2);
9268 }
9269 {
9270 PyThreadState* __tstate = wxPyBeginAllowThreads();
9271 result = (PyObject *)(arg1)->readlines(arg2);
9272 wxPyEndAllowThreads(__tstate);
9273 if (PyErr_Occurred()) SWIG_fail;
9274 }
9275 resultobj = result;
9276 return resultobj;
9277 fail:
9278 return NULL;
9279 }
9280
9281
9282 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9283 PyObject *resultobj = 0;
9284 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9285 int arg2 ;
9286 int arg3 = (int) 0 ;
9287 void *argp1 = 0 ;
9288 int res1 = 0 ;
9289 int val2 ;
9290 int ecode2 = 0 ;
9291 int val3 ;
9292 int ecode3 = 0 ;
9293 PyObject * obj0 = 0 ;
9294 PyObject * obj1 = 0 ;
9295 PyObject * obj2 = 0 ;
9296 char * kwnames[] = {
9297 (char *) "self",(char *) "offset",(char *) "whence", NULL
9298 };
9299
9300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9302 if (!SWIG_IsOK(res1)) {
9303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9304 }
9305 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9306 ecode2 = SWIG_AsVal_int(obj1, &val2);
9307 if (!SWIG_IsOK(ecode2)) {
9308 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9309 }
9310 arg2 = static_cast< int >(val2);
9311 if (obj2) {
9312 ecode3 = SWIG_AsVal_int(obj2, &val3);
9313 if (!SWIG_IsOK(ecode3)) {
9314 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9315 }
9316 arg3 = static_cast< int >(val3);
9317 }
9318 {
9319 PyThreadState* __tstate = wxPyBeginAllowThreads();
9320 (arg1)->seek(arg2,arg3);
9321 wxPyEndAllowThreads(__tstate);
9322 if (PyErr_Occurred()) SWIG_fail;
9323 }
9324 resultobj = SWIG_Py_Void();
9325 return resultobj;
9326 fail:
9327 return NULL;
9328 }
9329
9330
9331 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9332 PyObject *resultobj = 0;
9333 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9334 int result;
9335 void *argp1 = 0 ;
9336 int res1 = 0 ;
9337 PyObject *swig_obj[1] ;
9338
9339 if (!args) SWIG_fail;
9340 swig_obj[0] = args;
9341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9342 if (!SWIG_IsOK(res1)) {
9343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9344 }
9345 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9346 {
9347 PyThreadState* __tstate = wxPyBeginAllowThreads();
9348 result = (int)(arg1)->tell();
9349 wxPyEndAllowThreads(__tstate);
9350 if (PyErr_Occurred()) SWIG_fail;
9351 }
9352 resultobj = SWIG_From_int(static_cast< int >(result));
9353 return resultobj;
9354 fail:
9355 return NULL;
9356 }
9357
9358
9359 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9360 PyObject *resultobj = 0;
9361 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9362 char result;
9363 void *argp1 = 0 ;
9364 int res1 = 0 ;
9365 PyObject *swig_obj[1] ;
9366
9367 if (!args) SWIG_fail;
9368 swig_obj[0] = args;
9369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9370 if (!SWIG_IsOK(res1)) {
9371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9372 }
9373 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9374 {
9375 PyThreadState* __tstate = wxPyBeginAllowThreads();
9376 result = (char)(arg1)->Peek();
9377 wxPyEndAllowThreads(__tstate);
9378 if (PyErr_Occurred()) SWIG_fail;
9379 }
9380 resultobj = SWIG_From_char(static_cast< char >(result));
9381 return resultobj;
9382 fail:
9383 return NULL;
9384 }
9385
9386
9387 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9388 PyObject *resultobj = 0;
9389 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9390 char result;
9391 void *argp1 = 0 ;
9392 int res1 = 0 ;
9393 PyObject *swig_obj[1] ;
9394
9395 if (!args) SWIG_fail;
9396 swig_obj[0] = args;
9397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9398 if (!SWIG_IsOK(res1)) {
9399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9400 }
9401 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9402 {
9403 PyThreadState* __tstate = wxPyBeginAllowThreads();
9404 result = (char)(arg1)->GetC();
9405 wxPyEndAllowThreads(__tstate);
9406 if (PyErr_Occurred()) SWIG_fail;
9407 }
9408 resultobj = SWIG_From_char(static_cast< char >(result));
9409 return resultobj;
9410 fail:
9411 return NULL;
9412 }
9413
9414
9415 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9416 PyObject *resultobj = 0;
9417 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9418 size_t result;
9419 void *argp1 = 0 ;
9420 int res1 = 0 ;
9421 PyObject *swig_obj[1] ;
9422
9423 if (!args) SWIG_fail;
9424 swig_obj[0] = args;
9425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9426 if (!SWIG_IsOK(res1)) {
9427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9428 }
9429 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9430 {
9431 PyThreadState* __tstate = wxPyBeginAllowThreads();
9432 result = (size_t)(arg1)->LastRead();
9433 wxPyEndAllowThreads(__tstate);
9434 if (PyErr_Occurred()) SWIG_fail;
9435 }
9436 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9437 return resultobj;
9438 fail:
9439 return NULL;
9440 }
9441
9442
9443 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9444 PyObject *resultobj = 0;
9445 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9446 bool result;
9447 void *argp1 = 0 ;
9448 int res1 = 0 ;
9449 PyObject *swig_obj[1] ;
9450
9451 if (!args) SWIG_fail;
9452 swig_obj[0] = args;
9453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9454 if (!SWIG_IsOK(res1)) {
9455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9456 }
9457 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9458 {
9459 PyThreadState* __tstate = wxPyBeginAllowThreads();
9460 result = (bool)(arg1)->CanRead();
9461 wxPyEndAllowThreads(__tstate);
9462 if (PyErr_Occurred()) SWIG_fail;
9463 }
9464 {
9465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9466 }
9467 return resultobj;
9468 fail:
9469 return NULL;
9470 }
9471
9472
9473 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9474 PyObject *resultobj = 0;
9475 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9476 bool result;
9477 void *argp1 = 0 ;
9478 int res1 = 0 ;
9479 PyObject *swig_obj[1] ;
9480
9481 if (!args) SWIG_fail;
9482 swig_obj[0] = args;
9483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9484 if (!SWIG_IsOK(res1)) {
9485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9486 }
9487 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9488 {
9489 PyThreadState* __tstate = wxPyBeginAllowThreads();
9490 result = (bool)(arg1)->Eof();
9491 wxPyEndAllowThreads(__tstate);
9492 if (PyErr_Occurred()) SWIG_fail;
9493 }
9494 {
9495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9496 }
9497 return resultobj;
9498 fail:
9499 return NULL;
9500 }
9501
9502
9503 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9504 PyObject *resultobj = 0;
9505 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9506 char arg2 ;
9507 bool result;
9508 void *argp1 = 0 ;
9509 int res1 = 0 ;
9510 char val2 ;
9511 int ecode2 = 0 ;
9512 PyObject * obj0 = 0 ;
9513 PyObject * obj1 = 0 ;
9514 char * kwnames[] = {
9515 (char *) "self",(char *) "c", NULL
9516 };
9517
9518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9520 if (!SWIG_IsOK(res1)) {
9521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9522 }
9523 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9524 ecode2 = SWIG_AsVal_char(obj1, &val2);
9525 if (!SWIG_IsOK(ecode2)) {
9526 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9527 }
9528 arg2 = static_cast< char >(val2);
9529 {
9530 PyThreadState* __tstate = wxPyBeginAllowThreads();
9531 result = (bool)(arg1)->Ungetch(arg2);
9532 wxPyEndAllowThreads(__tstate);
9533 if (PyErr_Occurred()) SWIG_fail;
9534 }
9535 {
9536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9537 }
9538 return resultobj;
9539 fail:
9540 return NULL;
9541 }
9542
9543
9544 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9545 PyObject *resultobj = 0;
9546 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9547 long arg2 ;
9548 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9549 long result;
9550 void *argp1 = 0 ;
9551 int res1 = 0 ;
9552 long val2 ;
9553 int ecode2 = 0 ;
9554 int val3 ;
9555 int ecode3 = 0 ;
9556 PyObject * obj0 = 0 ;
9557 PyObject * obj1 = 0 ;
9558 PyObject * obj2 = 0 ;
9559 char * kwnames[] = {
9560 (char *) "self",(char *) "pos",(char *) "mode", NULL
9561 };
9562
9563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9565 if (!SWIG_IsOK(res1)) {
9566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9567 }
9568 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9569 ecode2 = SWIG_AsVal_long(obj1, &val2);
9570 if (!SWIG_IsOK(ecode2)) {
9571 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9572 }
9573 arg2 = static_cast< long >(val2);
9574 if (obj2) {
9575 ecode3 = SWIG_AsVal_int(obj2, &val3);
9576 if (!SWIG_IsOK(ecode3)) {
9577 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9578 }
9579 arg3 = static_cast< wxSeekMode >(val3);
9580 }
9581 {
9582 PyThreadState* __tstate = wxPyBeginAllowThreads();
9583 result = (long)(arg1)->SeekI(arg2,arg3);
9584 wxPyEndAllowThreads(__tstate);
9585 if (PyErr_Occurred()) SWIG_fail;
9586 }
9587 resultobj = SWIG_From_long(static_cast< long >(result));
9588 return resultobj;
9589 fail:
9590 return NULL;
9591 }
9592
9593
9594 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9595 PyObject *resultobj = 0;
9596 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9597 long result;
9598 void *argp1 = 0 ;
9599 int res1 = 0 ;
9600 PyObject *swig_obj[1] ;
9601
9602 if (!args) SWIG_fail;
9603 swig_obj[0] = args;
9604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9605 if (!SWIG_IsOK(res1)) {
9606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9607 }
9608 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9609 {
9610 PyThreadState* __tstate = wxPyBeginAllowThreads();
9611 result = (long)(arg1)->TellI();
9612 wxPyEndAllowThreads(__tstate);
9613 if (PyErr_Occurred()) SWIG_fail;
9614 }
9615 resultobj = SWIG_From_long(static_cast< long >(result));
9616 return resultobj;
9617 fail:
9618 return NULL;
9619 }
9620
9621
9622 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9623 PyObject *obj;
9624 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9625 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9626 return SWIG_Py_Void();
9627 }
9628
9629 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9630 return SWIG_Python_InitShadowInstance(args);
9631 }
9632
9633 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9634 PyObject *resultobj = 0;
9635 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9636 PyObject *arg2 = (PyObject *) 0 ;
9637 void *argp1 = 0 ;
9638 int res1 = 0 ;
9639 PyObject * obj0 = 0 ;
9640 PyObject * obj1 = 0 ;
9641 char * kwnames[] = {
9642 (char *) "self",(char *) "obj", NULL
9643 };
9644
9645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9647 if (!SWIG_IsOK(res1)) {
9648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9649 }
9650 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9651 arg2 = obj1;
9652 {
9653 PyThreadState* __tstate = wxPyBeginAllowThreads();
9654 wxOutputStream_write(arg1,arg2);
9655 wxPyEndAllowThreads(__tstate);
9656 if (PyErr_Occurred()) SWIG_fail;
9657 }
9658 resultobj = SWIG_Py_Void();
9659 return resultobj;
9660 fail:
9661 return NULL;
9662 }
9663
9664
9665 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9666 PyObject *resultobj = 0;
9667 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9668 size_t result;
9669 void *argp1 = 0 ;
9670 int res1 = 0 ;
9671 PyObject *swig_obj[1] ;
9672
9673 if (!args) SWIG_fail;
9674 swig_obj[0] = args;
9675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9676 if (!SWIG_IsOK(res1)) {
9677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9678 }
9679 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9680 {
9681 PyThreadState* __tstate = wxPyBeginAllowThreads();
9682 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9683 wxPyEndAllowThreads(__tstate);
9684 if (PyErr_Occurred()) SWIG_fail;
9685 }
9686 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9687 return resultobj;
9688 fail:
9689 return NULL;
9690 }
9691
9692
9693 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9694 PyObject *obj;
9695 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9696 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9697 return SWIG_Py_Void();
9698 }
9699
9700 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9701 PyObject *resultobj = 0;
9702 wxInputStream *arg1 = (wxInputStream *) 0 ;
9703 wxString *arg2 = 0 ;
9704 wxString *arg3 = 0 ;
9705 wxString *arg4 = 0 ;
9706 wxDateTime arg5 ;
9707 wxFSFile *result = 0 ;
9708 wxPyInputStream *temp1 ;
9709 bool temp2 = false ;
9710 bool temp3 = false ;
9711 bool temp4 = false ;
9712 void *argp5 ;
9713 int res5 = 0 ;
9714 PyObject * obj0 = 0 ;
9715 PyObject * obj1 = 0 ;
9716 PyObject * obj2 = 0 ;
9717 PyObject * obj3 = 0 ;
9718 PyObject * obj4 = 0 ;
9719 char * kwnames[] = {
9720 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9721 };
9722
9723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9724 {
9725 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9726 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9727 } else {
9728 PyErr_Clear(); // clear the failure of the wxPyConvert above
9729 arg1 = wxPyCBInputStream_create(obj0, true);
9730 if (arg1 == NULL) {
9731 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9732 SWIG_fail;
9733 }
9734 }
9735 }
9736 {
9737 arg2 = wxString_in_helper(obj1);
9738 if (arg2 == NULL) SWIG_fail;
9739 temp2 = true;
9740 }
9741 {
9742 arg3 = wxString_in_helper(obj2);
9743 if (arg3 == NULL) SWIG_fail;
9744 temp3 = true;
9745 }
9746 {
9747 arg4 = wxString_in_helper(obj3);
9748 if (arg4 == NULL) SWIG_fail;
9749 temp4 = true;
9750 }
9751 {
9752 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9753 if (!SWIG_IsOK(res5)) {
9754 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9755 }
9756 if (!argp5) {
9757 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9758 } else {
9759 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9760 arg5 = *temp;
9761 if (SWIG_IsNewObj(res5)) delete temp;
9762 }
9763 }
9764 {
9765 PyThreadState* __tstate = wxPyBeginAllowThreads();
9766 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9767 wxPyEndAllowThreads(__tstate);
9768 if (PyErr_Occurred()) SWIG_fail;
9769 }
9770 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
9771 {
9772 if (temp2)
9773 delete arg2;
9774 }
9775 {
9776 if (temp3)
9777 delete arg3;
9778 }
9779 {
9780 if (temp4)
9781 delete arg4;
9782 }
9783 return resultobj;
9784 fail:
9785 {
9786 if (temp2)
9787 delete arg2;
9788 }
9789 {
9790 if (temp3)
9791 delete arg3;
9792 }
9793 {
9794 if (temp4)
9795 delete arg4;
9796 }
9797 return NULL;
9798 }
9799
9800
9801 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9802 PyObject *resultobj = 0;
9803 wxFSFile *arg1 = (wxFSFile *) 0 ;
9804 void *argp1 = 0 ;
9805 int res1 = 0 ;
9806 PyObject *swig_obj[1] ;
9807
9808 if (!args) SWIG_fail;
9809 swig_obj[0] = args;
9810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
9811 if (!SWIG_IsOK(res1)) {
9812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
9813 }
9814 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9815 {
9816 PyThreadState* __tstate = wxPyBeginAllowThreads();
9817 delete arg1;
9818
9819 wxPyEndAllowThreads(__tstate);
9820 if (PyErr_Occurred()) SWIG_fail;
9821 }
9822 resultobj = SWIG_Py_Void();
9823 return resultobj;
9824 fail:
9825 return NULL;
9826 }
9827
9828
9829 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9830 PyObject *resultobj = 0;
9831 wxFSFile *arg1 = (wxFSFile *) 0 ;
9832 wxInputStream *result = 0 ;
9833 void *argp1 = 0 ;
9834 int res1 = 0 ;
9835 PyObject *swig_obj[1] ;
9836
9837 if (!args) SWIG_fail;
9838 swig_obj[0] = args;
9839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9840 if (!SWIG_IsOK(res1)) {
9841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9842 }
9843 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9844 {
9845 PyThreadState* __tstate = wxPyBeginAllowThreads();
9846 result = (wxInputStream *)(arg1)->GetStream();
9847 wxPyEndAllowThreads(__tstate);
9848 if (PyErr_Occurred()) SWIG_fail;
9849 }
9850 {
9851 wxPyInputStream * _ptr = NULL;
9852
9853 if (result) {
9854 _ptr = new wxPyInputStream(result);
9855 }
9856 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
9857 }
9858 return resultobj;
9859 fail:
9860 return NULL;
9861 }
9862
9863
9864 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9865 PyObject *resultobj = 0;
9866 wxFSFile *arg1 = (wxFSFile *) 0 ;
9867 wxString *result = 0 ;
9868 void *argp1 = 0 ;
9869 int res1 = 0 ;
9870 PyObject *swig_obj[1] ;
9871
9872 if (!args) SWIG_fail;
9873 swig_obj[0] = args;
9874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9875 if (!SWIG_IsOK(res1)) {
9876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
9877 }
9878 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9879 {
9880 PyThreadState* __tstate = wxPyBeginAllowThreads();
9881 {
9882 wxString const &_result_ref = (arg1)->GetMimeType();
9883 result = (wxString *) &_result_ref;
9884 }
9885 wxPyEndAllowThreads(__tstate);
9886 if (PyErr_Occurred()) SWIG_fail;
9887 }
9888 {
9889 #if wxUSE_UNICODE
9890 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9891 #else
9892 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9893 #endif
9894 }
9895 return resultobj;
9896 fail:
9897 return NULL;
9898 }
9899
9900
9901 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9902 PyObject *resultobj = 0;
9903 wxFSFile *arg1 = (wxFSFile *) 0 ;
9904 wxString *result = 0 ;
9905 void *argp1 = 0 ;
9906 int res1 = 0 ;
9907 PyObject *swig_obj[1] ;
9908
9909 if (!args) SWIG_fail;
9910 swig_obj[0] = args;
9911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9912 if (!SWIG_IsOK(res1)) {
9913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
9914 }
9915 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9916 {
9917 PyThreadState* __tstate = wxPyBeginAllowThreads();
9918 {
9919 wxString const &_result_ref = (arg1)->GetLocation();
9920 result = (wxString *) &_result_ref;
9921 }
9922 wxPyEndAllowThreads(__tstate);
9923 if (PyErr_Occurred()) SWIG_fail;
9924 }
9925 {
9926 #if wxUSE_UNICODE
9927 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9928 #else
9929 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9930 #endif
9931 }
9932 return resultobj;
9933 fail:
9934 return NULL;
9935 }
9936
9937
9938 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9939 PyObject *resultobj = 0;
9940 wxFSFile *arg1 = (wxFSFile *) 0 ;
9941 wxString *result = 0 ;
9942 void *argp1 = 0 ;
9943 int res1 = 0 ;
9944 PyObject *swig_obj[1] ;
9945
9946 if (!args) SWIG_fail;
9947 swig_obj[0] = args;
9948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9949 if (!SWIG_IsOK(res1)) {
9950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
9951 }
9952 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9953 {
9954 PyThreadState* __tstate = wxPyBeginAllowThreads();
9955 {
9956 wxString const &_result_ref = (arg1)->GetAnchor();
9957 result = (wxString *) &_result_ref;
9958 }
9959 wxPyEndAllowThreads(__tstate);
9960 if (PyErr_Occurred()) SWIG_fail;
9961 }
9962 {
9963 #if wxUSE_UNICODE
9964 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9965 #else
9966 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9967 #endif
9968 }
9969 return resultobj;
9970 fail:
9971 return NULL;
9972 }
9973
9974
9975 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9976 PyObject *resultobj = 0;
9977 wxFSFile *arg1 = (wxFSFile *) 0 ;
9978 wxDateTime result;
9979 void *argp1 = 0 ;
9980 int res1 = 0 ;
9981 PyObject *swig_obj[1] ;
9982
9983 if (!args) SWIG_fail;
9984 swig_obj[0] = args;
9985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9986 if (!SWIG_IsOK(res1)) {
9987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
9988 }
9989 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9990 {
9991 PyThreadState* __tstate = wxPyBeginAllowThreads();
9992 result = (arg1)->GetModificationTime();
9993 wxPyEndAllowThreads(__tstate);
9994 if (PyErr_Occurred()) SWIG_fail;
9995 }
9996 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
9997 return resultobj;
9998 fail:
9999 return NULL;
10000 }
10001
10002
10003 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10004 PyObject *obj;
10005 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10006 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
10007 return SWIG_Py_Void();
10008 }
10009
10010 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10011 return SWIG_Python_InitShadowInstance(args);
10012 }
10013
10014 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10015 PyObject *resultobj = 0;
10016 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10017 void *argp1 = 0 ;
10018 int res1 = 0 ;
10019 PyObject *swig_obj[1] ;
10020
10021 if (!args) SWIG_fail;
10022 swig_obj[0] = args;
10023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10024 if (!SWIG_IsOK(res1)) {
10025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10026 }
10027 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
10028 {
10029 PyThreadState* __tstate = wxPyBeginAllowThreads();
10030 delete arg1;
10031
10032 wxPyEndAllowThreads(__tstate);
10033 if (PyErr_Occurred()) SWIG_fail;
10034 }
10035 resultobj = SWIG_Py_Void();
10036 return resultobj;
10037 fail:
10038 return NULL;
10039 }
10040
10041
10042 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10043 PyObject *obj;
10044 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10045 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
10046 return SWIG_Py_Void();
10047 }
10048
10049 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10050 PyObject *resultobj = 0;
10051 wxPyFileSystemHandler *result = 0 ;
10052
10053 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
10054 {
10055 PyThreadState* __tstate = wxPyBeginAllowThreads();
10056 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
10057 wxPyEndAllowThreads(__tstate);
10058 if (PyErr_Occurred()) SWIG_fail;
10059 }
10060 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
10061 return resultobj;
10062 fail:
10063 return NULL;
10064 }
10065
10066
10067 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10068 PyObject *resultobj = 0;
10069 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10070 PyObject *arg2 = (PyObject *) 0 ;
10071 PyObject *arg3 = (PyObject *) 0 ;
10072 void *argp1 = 0 ;
10073 int res1 = 0 ;
10074 PyObject * obj0 = 0 ;
10075 PyObject * obj1 = 0 ;
10076 PyObject * obj2 = 0 ;
10077 char * kwnames[] = {
10078 (char *) "self",(char *) "self",(char *) "_class", NULL
10079 };
10080
10081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10083 if (!SWIG_IsOK(res1)) {
10084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10085 }
10086 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10087 arg2 = obj1;
10088 arg3 = obj2;
10089 {
10090 PyThreadState* __tstate = wxPyBeginAllowThreads();
10091 (arg1)->_setCallbackInfo(arg2,arg3);
10092 wxPyEndAllowThreads(__tstate);
10093 if (PyErr_Occurred()) SWIG_fail;
10094 }
10095 resultobj = SWIG_Py_Void();
10096 return resultobj;
10097 fail:
10098 return NULL;
10099 }
10100
10101
10102 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10103 PyObject *resultobj = 0;
10104 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10105 wxString *arg2 = 0 ;
10106 bool result;
10107 void *argp1 = 0 ;
10108 int res1 = 0 ;
10109 bool temp2 = false ;
10110 PyObject * obj0 = 0 ;
10111 PyObject * obj1 = 0 ;
10112 char * kwnames[] = {
10113 (char *) "self",(char *) "location", NULL
10114 };
10115
10116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10118 if (!SWIG_IsOK(res1)) {
10119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10120 }
10121 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10122 {
10123 arg2 = wxString_in_helper(obj1);
10124 if (arg2 == NULL) SWIG_fail;
10125 temp2 = true;
10126 }
10127 {
10128 PyThreadState* __tstate = wxPyBeginAllowThreads();
10129 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10130 wxPyEndAllowThreads(__tstate);
10131 if (PyErr_Occurred()) SWIG_fail;
10132 }
10133 {
10134 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10135 }
10136 {
10137 if (temp2)
10138 delete arg2;
10139 }
10140 return resultobj;
10141 fail:
10142 {
10143 if (temp2)
10144 delete arg2;
10145 }
10146 return NULL;
10147 }
10148
10149
10150 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10151 PyObject *resultobj = 0;
10152 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10153 wxFileSystem *arg2 = 0 ;
10154 wxString *arg3 = 0 ;
10155 wxFSFile *result = 0 ;
10156 void *argp1 = 0 ;
10157 int res1 = 0 ;
10158 void *argp2 = 0 ;
10159 int res2 = 0 ;
10160 bool temp3 = false ;
10161 PyObject * obj0 = 0 ;
10162 PyObject * obj1 = 0 ;
10163 PyObject * obj2 = 0 ;
10164 char * kwnames[] = {
10165 (char *) "self",(char *) "fs",(char *) "location", NULL
10166 };
10167
10168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10170 if (!SWIG_IsOK(res1)) {
10171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10172 }
10173 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10174 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10175 if (!SWIG_IsOK(res2)) {
10176 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10177 }
10178 if (!argp2) {
10179 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10180 }
10181 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10182 {
10183 arg3 = wxString_in_helper(obj2);
10184 if (arg3 == NULL) SWIG_fail;
10185 temp3 = true;
10186 }
10187 {
10188 PyThreadState* __tstate = wxPyBeginAllowThreads();
10189 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10190 wxPyEndAllowThreads(__tstate);
10191 if (PyErr_Occurred()) SWIG_fail;
10192 }
10193 {
10194 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10195 }
10196 {
10197 if (temp3)
10198 delete arg3;
10199 }
10200 return resultobj;
10201 fail:
10202 {
10203 if (temp3)
10204 delete arg3;
10205 }
10206 return NULL;
10207 }
10208
10209
10210 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10211 PyObject *resultobj = 0;
10212 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10213 wxString *arg2 = 0 ;
10214 int arg3 = (int) 0 ;
10215 wxString result;
10216 void *argp1 = 0 ;
10217 int res1 = 0 ;
10218 bool temp2 = false ;
10219 int val3 ;
10220 int ecode3 = 0 ;
10221 PyObject * obj0 = 0 ;
10222 PyObject * obj1 = 0 ;
10223 PyObject * obj2 = 0 ;
10224 char * kwnames[] = {
10225 (char *) "self",(char *) "spec",(char *) "flags", NULL
10226 };
10227
10228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10230 if (!SWIG_IsOK(res1)) {
10231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10232 }
10233 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10234 {
10235 arg2 = wxString_in_helper(obj1);
10236 if (arg2 == NULL) SWIG_fail;
10237 temp2 = true;
10238 }
10239 if (obj2) {
10240 ecode3 = SWIG_AsVal_int(obj2, &val3);
10241 if (!SWIG_IsOK(ecode3)) {
10242 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10243 }
10244 arg3 = static_cast< int >(val3);
10245 }
10246 {
10247 PyThreadState* __tstate = wxPyBeginAllowThreads();
10248 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10249 wxPyEndAllowThreads(__tstate);
10250 if (PyErr_Occurred()) SWIG_fail;
10251 }
10252 {
10253 #if wxUSE_UNICODE
10254 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10255 #else
10256 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10257 #endif
10258 }
10259 {
10260 if (temp2)
10261 delete arg2;
10262 }
10263 return resultobj;
10264 fail:
10265 {
10266 if (temp2)
10267 delete arg2;
10268 }
10269 return NULL;
10270 }
10271
10272
10273 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10274 PyObject *resultobj = 0;
10275 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10276 wxString result;
10277 void *argp1 = 0 ;
10278 int res1 = 0 ;
10279 PyObject *swig_obj[1] ;
10280
10281 if (!args) SWIG_fail;
10282 swig_obj[0] = args;
10283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10284 if (!SWIG_IsOK(res1)) {
10285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10286 }
10287 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10288 {
10289 PyThreadState* __tstate = wxPyBeginAllowThreads();
10290 result = (arg1)->FindNext();
10291 wxPyEndAllowThreads(__tstate);
10292 if (PyErr_Occurred()) SWIG_fail;
10293 }
10294 {
10295 #if wxUSE_UNICODE
10296 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10297 #else
10298 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10299 #endif
10300 }
10301 return resultobj;
10302 fail:
10303 return NULL;
10304 }
10305
10306
10307 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10308 PyObject *resultobj = 0;
10309 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10310 wxString *arg2 = 0 ;
10311 wxString result;
10312 void *argp1 = 0 ;
10313 int res1 = 0 ;
10314 bool temp2 = false ;
10315 PyObject * obj0 = 0 ;
10316 PyObject * obj1 = 0 ;
10317 char * kwnames[] = {
10318 (char *) "self",(char *) "location", NULL
10319 };
10320
10321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10323 if (!SWIG_IsOK(res1)) {
10324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10325 }
10326 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10327 {
10328 arg2 = wxString_in_helper(obj1);
10329 if (arg2 == NULL) SWIG_fail;
10330 temp2 = true;
10331 }
10332 {
10333 PyThreadState* __tstate = wxPyBeginAllowThreads();
10334 result = (arg1)->GetProtocol((wxString const &)*arg2);
10335 wxPyEndAllowThreads(__tstate);
10336 if (PyErr_Occurred()) SWIG_fail;
10337 }
10338 {
10339 #if wxUSE_UNICODE
10340 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10341 #else
10342 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10343 #endif
10344 }
10345 {
10346 if (temp2)
10347 delete arg2;
10348 }
10349 return resultobj;
10350 fail:
10351 {
10352 if (temp2)
10353 delete arg2;
10354 }
10355 return NULL;
10356 }
10357
10358
10359 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10360 PyObject *resultobj = 0;
10361 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10362 wxString *arg2 = 0 ;
10363 wxString result;
10364 void *argp1 = 0 ;
10365 int res1 = 0 ;
10366 bool temp2 = false ;
10367 PyObject * obj0 = 0 ;
10368 PyObject * obj1 = 0 ;
10369 char * kwnames[] = {
10370 (char *) "self",(char *) "location", NULL
10371 };
10372
10373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10375 if (!SWIG_IsOK(res1)) {
10376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10377 }
10378 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10379 {
10380 arg2 = wxString_in_helper(obj1);
10381 if (arg2 == NULL) SWIG_fail;
10382 temp2 = true;
10383 }
10384 {
10385 PyThreadState* __tstate = wxPyBeginAllowThreads();
10386 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10387 wxPyEndAllowThreads(__tstate);
10388 if (PyErr_Occurred()) SWIG_fail;
10389 }
10390 {
10391 #if wxUSE_UNICODE
10392 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10393 #else
10394 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10395 #endif
10396 }
10397 {
10398 if (temp2)
10399 delete arg2;
10400 }
10401 return resultobj;
10402 fail:
10403 {
10404 if (temp2)
10405 delete arg2;
10406 }
10407 return NULL;
10408 }
10409
10410
10411 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10412 PyObject *resultobj = 0;
10413 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10414 wxString *arg2 = 0 ;
10415 wxString result;
10416 void *argp1 = 0 ;
10417 int res1 = 0 ;
10418 bool temp2 = false ;
10419 PyObject * obj0 = 0 ;
10420 PyObject * obj1 = 0 ;
10421 char * kwnames[] = {
10422 (char *) "self",(char *) "location", NULL
10423 };
10424
10425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10427 if (!SWIG_IsOK(res1)) {
10428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10429 }
10430 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10431 {
10432 arg2 = wxString_in_helper(obj1);
10433 if (arg2 == NULL) SWIG_fail;
10434 temp2 = true;
10435 }
10436 {
10437 PyThreadState* __tstate = wxPyBeginAllowThreads();
10438 result = (arg1)->GetAnchor((wxString const &)*arg2);
10439 wxPyEndAllowThreads(__tstate);
10440 if (PyErr_Occurred()) SWIG_fail;
10441 }
10442 {
10443 #if wxUSE_UNICODE
10444 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10445 #else
10446 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10447 #endif
10448 }
10449 {
10450 if (temp2)
10451 delete arg2;
10452 }
10453 return resultobj;
10454 fail:
10455 {
10456 if (temp2)
10457 delete arg2;
10458 }
10459 return NULL;
10460 }
10461
10462
10463 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10464 PyObject *resultobj = 0;
10465 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10466 wxString *arg2 = 0 ;
10467 wxString result;
10468 void *argp1 = 0 ;
10469 int res1 = 0 ;
10470 bool temp2 = false ;
10471 PyObject * obj0 = 0 ;
10472 PyObject * obj1 = 0 ;
10473 char * kwnames[] = {
10474 (char *) "self",(char *) "location", NULL
10475 };
10476
10477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10479 if (!SWIG_IsOK(res1)) {
10480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10481 }
10482 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10483 {
10484 arg2 = wxString_in_helper(obj1);
10485 if (arg2 == NULL) SWIG_fail;
10486 temp2 = true;
10487 }
10488 {
10489 PyThreadState* __tstate = wxPyBeginAllowThreads();
10490 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10491 wxPyEndAllowThreads(__tstate);
10492 if (PyErr_Occurred()) SWIG_fail;
10493 }
10494 {
10495 #if wxUSE_UNICODE
10496 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10497 #else
10498 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10499 #endif
10500 }
10501 {
10502 if (temp2)
10503 delete arg2;
10504 }
10505 return resultobj;
10506 fail:
10507 {
10508 if (temp2)
10509 delete arg2;
10510 }
10511 return NULL;
10512 }
10513
10514
10515 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10516 PyObject *resultobj = 0;
10517 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10518 wxString *arg2 = 0 ;
10519 wxString result;
10520 void *argp1 = 0 ;
10521 int res1 = 0 ;
10522 bool temp2 = false ;
10523 PyObject * obj0 = 0 ;
10524 PyObject * obj1 = 0 ;
10525 char * kwnames[] = {
10526 (char *) "self",(char *) "location", NULL
10527 };
10528
10529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10531 if (!SWIG_IsOK(res1)) {
10532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10533 }
10534 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10535 {
10536 arg2 = wxString_in_helper(obj1);
10537 if (arg2 == NULL) SWIG_fail;
10538 temp2 = true;
10539 }
10540 {
10541 PyThreadState* __tstate = wxPyBeginAllowThreads();
10542 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10543 wxPyEndAllowThreads(__tstate);
10544 if (PyErr_Occurred()) SWIG_fail;
10545 }
10546 {
10547 #if wxUSE_UNICODE
10548 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10549 #else
10550 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10551 #endif
10552 }
10553 {
10554 if (temp2)
10555 delete arg2;
10556 }
10557 return resultobj;
10558 fail:
10559 {
10560 if (temp2)
10561 delete arg2;
10562 }
10563 return NULL;
10564 }
10565
10566
10567 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10568 PyObject *obj;
10569 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10570 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10571 return SWIG_Py_Void();
10572 }
10573
10574 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10575 return SWIG_Python_InitShadowInstance(args);
10576 }
10577
10578 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10579 PyObject *resultobj = 0;
10580 wxFileSystem *result = 0 ;
10581
10582 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10583 {
10584 PyThreadState* __tstate = wxPyBeginAllowThreads();
10585 result = (wxFileSystem *)new wxFileSystem();
10586 wxPyEndAllowThreads(__tstate);
10587 if (PyErr_Occurred()) SWIG_fail;
10588 }
10589 {
10590 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10591 }
10592 return resultobj;
10593 fail:
10594 return NULL;
10595 }
10596
10597
10598 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10599 PyObject *resultobj = 0;
10600 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10601 void *argp1 = 0 ;
10602 int res1 = 0 ;
10603 PyObject *swig_obj[1] ;
10604
10605 if (!args) SWIG_fail;
10606 swig_obj[0] = args;
10607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10608 if (!SWIG_IsOK(res1)) {
10609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10610 }
10611 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10612 {
10613 PyThreadState* __tstate = wxPyBeginAllowThreads();
10614 delete arg1;
10615
10616 wxPyEndAllowThreads(__tstate);
10617 if (PyErr_Occurred()) SWIG_fail;
10618 }
10619 resultobj = SWIG_Py_Void();
10620 return resultobj;
10621 fail:
10622 return NULL;
10623 }
10624
10625
10626 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10627 PyObject *resultobj = 0;
10628 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10629 wxString *arg2 = 0 ;
10630 bool arg3 = (bool) false ;
10631 void *argp1 = 0 ;
10632 int res1 = 0 ;
10633 bool temp2 = false ;
10634 bool val3 ;
10635 int ecode3 = 0 ;
10636 PyObject * obj0 = 0 ;
10637 PyObject * obj1 = 0 ;
10638 PyObject * obj2 = 0 ;
10639 char * kwnames[] = {
10640 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10641 };
10642
10643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10645 if (!SWIG_IsOK(res1)) {
10646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10647 }
10648 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10649 {
10650 arg2 = wxString_in_helper(obj1);
10651 if (arg2 == NULL) SWIG_fail;
10652 temp2 = true;
10653 }
10654 if (obj2) {
10655 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10656 if (!SWIG_IsOK(ecode3)) {
10657 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10658 }
10659 arg3 = static_cast< bool >(val3);
10660 }
10661 {
10662 PyThreadState* __tstate = wxPyBeginAllowThreads();
10663 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10664 wxPyEndAllowThreads(__tstate);
10665 if (PyErr_Occurred()) SWIG_fail;
10666 }
10667 resultobj = SWIG_Py_Void();
10668 {
10669 if (temp2)
10670 delete arg2;
10671 }
10672 return resultobj;
10673 fail:
10674 {
10675 if (temp2)
10676 delete arg2;
10677 }
10678 return NULL;
10679 }
10680
10681
10682 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10683 PyObject *resultobj = 0;
10684 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10685 wxString result;
10686 void *argp1 = 0 ;
10687 int res1 = 0 ;
10688 PyObject *swig_obj[1] ;
10689
10690 if (!args) SWIG_fail;
10691 swig_obj[0] = args;
10692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10693 if (!SWIG_IsOK(res1)) {
10694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10695 }
10696 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10697 {
10698 PyThreadState* __tstate = wxPyBeginAllowThreads();
10699 result = (arg1)->GetPath();
10700 wxPyEndAllowThreads(__tstate);
10701 if (PyErr_Occurred()) SWIG_fail;
10702 }
10703 {
10704 #if wxUSE_UNICODE
10705 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10706 #else
10707 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10708 #endif
10709 }
10710 return resultobj;
10711 fail:
10712 return NULL;
10713 }
10714
10715
10716 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10717 PyObject *resultobj = 0;
10718 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10719 wxString *arg2 = 0 ;
10720 wxFSFile *result = 0 ;
10721 void *argp1 = 0 ;
10722 int res1 = 0 ;
10723 bool temp2 = false ;
10724 PyObject * obj0 = 0 ;
10725 PyObject * obj1 = 0 ;
10726 char * kwnames[] = {
10727 (char *) "self",(char *) "location", NULL
10728 };
10729
10730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10732 if (!SWIG_IsOK(res1)) {
10733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10734 }
10735 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10736 {
10737 arg2 = wxString_in_helper(obj1);
10738 if (arg2 == NULL) SWIG_fail;
10739 temp2 = true;
10740 }
10741 {
10742 PyThreadState* __tstate = wxPyBeginAllowThreads();
10743 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10744 wxPyEndAllowThreads(__tstate);
10745 if (PyErr_Occurred()) SWIG_fail;
10746 }
10747 {
10748 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10749 }
10750 {
10751 if (temp2)
10752 delete arg2;
10753 }
10754 return resultobj;
10755 fail:
10756 {
10757 if (temp2)
10758 delete arg2;
10759 }
10760 return NULL;
10761 }
10762
10763
10764 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10765 PyObject *resultobj = 0;
10766 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10767 wxString *arg2 = 0 ;
10768 int arg3 = (int) 0 ;
10769 wxString result;
10770 void *argp1 = 0 ;
10771 int res1 = 0 ;
10772 bool temp2 = false ;
10773 int val3 ;
10774 int ecode3 = 0 ;
10775 PyObject * obj0 = 0 ;
10776 PyObject * obj1 = 0 ;
10777 PyObject * obj2 = 0 ;
10778 char * kwnames[] = {
10779 (char *) "self",(char *) "spec",(char *) "flags", NULL
10780 };
10781
10782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10784 if (!SWIG_IsOK(res1)) {
10785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10786 }
10787 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10788 {
10789 arg2 = wxString_in_helper(obj1);
10790 if (arg2 == NULL) SWIG_fail;
10791 temp2 = true;
10792 }
10793 if (obj2) {
10794 ecode3 = SWIG_AsVal_int(obj2, &val3);
10795 if (!SWIG_IsOK(ecode3)) {
10796 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
10797 }
10798 arg3 = static_cast< int >(val3);
10799 }
10800 {
10801 PyThreadState* __tstate = wxPyBeginAllowThreads();
10802 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10803 wxPyEndAllowThreads(__tstate);
10804 if (PyErr_Occurred()) SWIG_fail;
10805 }
10806 {
10807 #if wxUSE_UNICODE
10808 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10809 #else
10810 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10811 #endif
10812 }
10813 {
10814 if (temp2)
10815 delete arg2;
10816 }
10817 return resultobj;
10818 fail:
10819 {
10820 if (temp2)
10821 delete arg2;
10822 }
10823 return NULL;
10824 }
10825
10826
10827 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10828 PyObject *resultobj = 0;
10829 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10830 wxString result;
10831 void *argp1 = 0 ;
10832 int res1 = 0 ;
10833 PyObject *swig_obj[1] ;
10834
10835 if (!args) SWIG_fail;
10836 swig_obj[0] = args;
10837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10838 if (!SWIG_IsOK(res1)) {
10839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10840 }
10841 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10842 {
10843 PyThreadState* __tstate = wxPyBeginAllowThreads();
10844 result = (arg1)->FindNext();
10845 wxPyEndAllowThreads(__tstate);
10846 if (PyErr_Occurred()) SWIG_fail;
10847 }
10848 {
10849 #if wxUSE_UNICODE
10850 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10851 #else
10852 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10853 #endif
10854 }
10855 return resultobj;
10856 fail:
10857 return NULL;
10858 }
10859
10860
10861 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10862 PyObject *resultobj = 0;
10863 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10864 int res1 = 0 ;
10865 PyObject * obj0 = 0 ;
10866 char * kwnames[] = {
10867 (char *) "handler", NULL
10868 };
10869
10870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
10871 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10872 if (!SWIG_IsOK(res1)) {
10873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10874 }
10875 {
10876 PyThreadState* __tstate = wxPyBeginAllowThreads();
10877 wxFileSystem::AddHandler(arg1);
10878 wxPyEndAllowThreads(__tstate);
10879 if (PyErr_Occurred()) SWIG_fail;
10880 }
10881 resultobj = SWIG_Py_Void();
10882 return resultobj;
10883 fail:
10884 return NULL;
10885 }
10886
10887
10888 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10889 PyObject *resultobj = 0;
10890
10891 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
10892 {
10893 PyThreadState* __tstate = wxPyBeginAllowThreads();
10894 wxFileSystem::CleanUpHandlers();
10895 wxPyEndAllowThreads(__tstate);
10896 if (PyErr_Occurred()) SWIG_fail;
10897 }
10898 resultobj = SWIG_Py_Void();
10899 return resultobj;
10900 fail:
10901 return NULL;
10902 }
10903
10904
10905 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10906 PyObject *resultobj = 0;
10907 wxString *arg1 = 0 ;
10908 wxString result;
10909 bool temp1 = false ;
10910 PyObject * obj0 = 0 ;
10911 char * kwnames[] = {
10912 (char *) "filename", NULL
10913 };
10914
10915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
10916 {
10917 arg1 = wxString_in_helper(obj0);
10918 if (arg1 == NULL) SWIG_fail;
10919 temp1 = true;
10920 }
10921 {
10922 PyThreadState* __tstate = wxPyBeginAllowThreads();
10923 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
10924 wxPyEndAllowThreads(__tstate);
10925 if (PyErr_Occurred()) SWIG_fail;
10926 }
10927 {
10928 #if wxUSE_UNICODE
10929 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10930 #else
10931 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10932 #endif
10933 }
10934 {
10935 if (temp1)
10936 delete arg1;
10937 }
10938 return resultobj;
10939 fail:
10940 {
10941 if (temp1)
10942 delete arg1;
10943 }
10944 return NULL;
10945 }
10946
10947
10948 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10949 PyObject *resultobj = 0;
10950 wxString *arg1 = 0 ;
10951 wxString result;
10952 bool temp1 = false ;
10953 PyObject * obj0 = 0 ;
10954 char * kwnames[] = {
10955 (char *) "url", NULL
10956 };
10957
10958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
10959 {
10960 arg1 = wxString_in_helper(obj0);
10961 if (arg1 == NULL) SWIG_fail;
10962 temp1 = true;
10963 }
10964 {
10965 PyThreadState* __tstate = wxPyBeginAllowThreads();
10966 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
10967 wxPyEndAllowThreads(__tstate);
10968 if (PyErr_Occurred()) SWIG_fail;
10969 }
10970 {
10971 #if wxUSE_UNICODE
10972 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10973 #else
10974 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10975 #endif
10976 }
10977 {
10978 if (temp1)
10979 delete arg1;
10980 }
10981 return resultobj;
10982 fail:
10983 {
10984 if (temp1)
10985 delete arg1;
10986 }
10987 return NULL;
10988 }
10989
10990
10991 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10992 PyObject *obj;
10993 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10994 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
10995 return SWIG_Py_Void();
10996 }
10997
10998 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10999 return SWIG_Python_InitShadowInstance(args);
11000 }
11001
11002 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11003 PyObject *resultobj = 0;
11004 wxInternetFSHandler *result = 0 ;
11005
11006 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
11007 {
11008 PyThreadState* __tstate = wxPyBeginAllowThreads();
11009 result = (wxInternetFSHandler *)new wxInternetFSHandler();
11010 wxPyEndAllowThreads(__tstate);
11011 if (PyErr_Occurred()) SWIG_fail;
11012 }
11013 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
11014 return resultobj;
11015 fail:
11016 return NULL;
11017 }
11018
11019
11020 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11021 PyObject *resultobj = 0;
11022 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11023 wxString *arg2 = 0 ;
11024 bool result;
11025 void *argp1 = 0 ;
11026 int res1 = 0 ;
11027 bool temp2 = false ;
11028 PyObject * obj0 = 0 ;
11029 PyObject * obj1 = 0 ;
11030 char * kwnames[] = {
11031 (char *) "self",(char *) "location", NULL
11032 };
11033
11034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11036 if (!SWIG_IsOK(res1)) {
11037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11038 }
11039 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11040 {
11041 arg2 = wxString_in_helper(obj1);
11042 if (arg2 == NULL) SWIG_fail;
11043 temp2 = true;
11044 }
11045 {
11046 PyThreadState* __tstate = wxPyBeginAllowThreads();
11047 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11048 wxPyEndAllowThreads(__tstate);
11049 if (PyErr_Occurred()) SWIG_fail;
11050 }
11051 {
11052 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11053 }
11054 {
11055 if (temp2)
11056 delete arg2;
11057 }
11058 return resultobj;
11059 fail:
11060 {
11061 if (temp2)
11062 delete arg2;
11063 }
11064 return NULL;
11065 }
11066
11067
11068 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11069 PyObject *resultobj = 0;
11070 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11071 wxFileSystem *arg2 = 0 ;
11072 wxString *arg3 = 0 ;
11073 wxFSFile *result = 0 ;
11074 void *argp1 = 0 ;
11075 int res1 = 0 ;
11076 void *argp2 = 0 ;
11077 int res2 = 0 ;
11078 bool temp3 = false ;
11079 PyObject * obj0 = 0 ;
11080 PyObject * obj1 = 0 ;
11081 PyObject * obj2 = 0 ;
11082 char * kwnames[] = {
11083 (char *) "self",(char *) "fs",(char *) "location", NULL
11084 };
11085
11086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11088 if (!SWIG_IsOK(res1)) {
11089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11090 }
11091 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11092 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11093 if (!SWIG_IsOK(res2)) {
11094 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11095 }
11096 if (!argp2) {
11097 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11098 }
11099 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11100 {
11101 arg3 = wxString_in_helper(obj2);
11102 if (arg3 == NULL) SWIG_fail;
11103 temp3 = true;
11104 }
11105 {
11106 PyThreadState* __tstate = wxPyBeginAllowThreads();
11107 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11108 wxPyEndAllowThreads(__tstate);
11109 if (PyErr_Occurred()) SWIG_fail;
11110 }
11111 {
11112 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11113 }
11114 {
11115 if (temp3)
11116 delete arg3;
11117 }
11118 return resultobj;
11119 fail:
11120 {
11121 if (temp3)
11122 delete arg3;
11123 }
11124 return NULL;
11125 }
11126
11127
11128 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11129 PyObject *obj;
11130 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11131 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11132 return SWIG_Py_Void();
11133 }
11134
11135 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11136 return SWIG_Python_InitShadowInstance(args);
11137 }
11138
11139 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11140 PyObject *resultobj = 0;
11141 wxZipFSHandler *result = 0 ;
11142
11143 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11144 {
11145 PyThreadState* __tstate = wxPyBeginAllowThreads();
11146 result = (wxZipFSHandler *)new wxZipFSHandler();
11147 wxPyEndAllowThreads(__tstate);
11148 if (PyErr_Occurred()) SWIG_fail;
11149 }
11150 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11151 return resultobj;
11152 fail:
11153 return NULL;
11154 }
11155
11156
11157 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11158 PyObject *resultobj = 0;
11159 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11160 wxString *arg2 = 0 ;
11161 bool result;
11162 void *argp1 = 0 ;
11163 int res1 = 0 ;
11164 bool temp2 = false ;
11165 PyObject * obj0 = 0 ;
11166 PyObject * obj1 = 0 ;
11167 char * kwnames[] = {
11168 (char *) "self",(char *) "location", NULL
11169 };
11170
11171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11173 if (!SWIG_IsOK(res1)) {
11174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11175 }
11176 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11177 {
11178 arg2 = wxString_in_helper(obj1);
11179 if (arg2 == NULL) SWIG_fail;
11180 temp2 = true;
11181 }
11182 {
11183 PyThreadState* __tstate = wxPyBeginAllowThreads();
11184 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11185 wxPyEndAllowThreads(__tstate);
11186 if (PyErr_Occurred()) SWIG_fail;
11187 }
11188 {
11189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11190 }
11191 {
11192 if (temp2)
11193 delete arg2;
11194 }
11195 return resultobj;
11196 fail:
11197 {
11198 if (temp2)
11199 delete arg2;
11200 }
11201 return NULL;
11202 }
11203
11204
11205 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11206 PyObject *resultobj = 0;
11207 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11208 wxFileSystem *arg2 = 0 ;
11209 wxString *arg3 = 0 ;
11210 wxFSFile *result = 0 ;
11211 void *argp1 = 0 ;
11212 int res1 = 0 ;
11213 void *argp2 = 0 ;
11214 int res2 = 0 ;
11215 bool temp3 = false ;
11216 PyObject * obj0 = 0 ;
11217 PyObject * obj1 = 0 ;
11218 PyObject * obj2 = 0 ;
11219 char * kwnames[] = {
11220 (char *) "self",(char *) "fs",(char *) "location", NULL
11221 };
11222
11223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11225 if (!SWIG_IsOK(res1)) {
11226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11227 }
11228 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11229 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11230 if (!SWIG_IsOK(res2)) {
11231 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11232 }
11233 if (!argp2) {
11234 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11235 }
11236 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11237 {
11238 arg3 = wxString_in_helper(obj2);
11239 if (arg3 == NULL) SWIG_fail;
11240 temp3 = true;
11241 }
11242 {
11243 PyThreadState* __tstate = wxPyBeginAllowThreads();
11244 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11245 wxPyEndAllowThreads(__tstate);
11246 if (PyErr_Occurred()) SWIG_fail;
11247 }
11248 {
11249 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11250 }
11251 {
11252 if (temp3)
11253 delete arg3;
11254 }
11255 return resultobj;
11256 fail:
11257 {
11258 if (temp3)
11259 delete arg3;
11260 }
11261 return NULL;
11262 }
11263
11264
11265 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11266 PyObject *resultobj = 0;
11267 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11268 wxString *arg2 = 0 ;
11269 int arg3 = (int) 0 ;
11270 wxString result;
11271 void *argp1 = 0 ;
11272 int res1 = 0 ;
11273 bool temp2 = false ;
11274 int val3 ;
11275 int ecode3 = 0 ;
11276 PyObject * obj0 = 0 ;
11277 PyObject * obj1 = 0 ;
11278 PyObject * obj2 = 0 ;
11279 char * kwnames[] = {
11280 (char *) "self",(char *) "spec",(char *) "flags", NULL
11281 };
11282
11283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11285 if (!SWIG_IsOK(res1)) {
11286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11287 }
11288 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11289 {
11290 arg2 = wxString_in_helper(obj1);
11291 if (arg2 == NULL) SWIG_fail;
11292 temp2 = true;
11293 }
11294 if (obj2) {
11295 ecode3 = SWIG_AsVal_int(obj2, &val3);
11296 if (!SWIG_IsOK(ecode3)) {
11297 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11298 }
11299 arg3 = static_cast< int >(val3);
11300 }
11301 {
11302 PyThreadState* __tstate = wxPyBeginAllowThreads();
11303 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11304 wxPyEndAllowThreads(__tstate);
11305 if (PyErr_Occurred()) SWIG_fail;
11306 }
11307 {
11308 #if wxUSE_UNICODE
11309 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11310 #else
11311 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11312 #endif
11313 }
11314 {
11315 if (temp2)
11316 delete arg2;
11317 }
11318 return resultobj;
11319 fail:
11320 {
11321 if (temp2)
11322 delete arg2;
11323 }
11324 return NULL;
11325 }
11326
11327
11328 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11329 PyObject *resultobj = 0;
11330 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11331 wxString result;
11332 void *argp1 = 0 ;
11333 int res1 = 0 ;
11334 PyObject *swig_obj[1] ;
11335
11336 if (!args) SWIG_fail;
11337 swig_obj[0] = args;
11338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11339 if (!SWIG_IsOK(res1)) {
11340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11341 }
11342 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11343 {
11344 PyThreadState* __tstate = wxPyBeginAllowThreads();
11345 result = (arg1)->FindNext();
11346 wxPyEndAllowThreads(__tstate);
11347 if (PyErr_Occurred()) SWIG_fail;
11348 }
11349 {
11350 #if wxUSE_UNICODE
11351 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11352 #else
11353 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11354 #endif
11355 }
11356 return resultobj;
11357 fail:
11358 return NULL;
11359 }
11360
11361
11362 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11363 PyObject *obj;
11364 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11365 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11366 return SWIG_Py_Void();
11367 }
11368
11369 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11370 return SWIG_Python_InitShadowInstance(args);
11371 }
11372
11373 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11374 PyObject *resultobj = 0;
11375 wxString *arg1 = 0 ;
11376 wxImage *arg2 = 0 ;
11377 long arg3 ;
11378 bool temp1 = false ;
11379 void *argp2 = 0 ;
11380 int res2 = 0 ;
11381 long val3 ;
11382 int ecode3 = 0 ;
11383 PyObject * obj0 = 0 ;
11384 PyObject * obj1 = 0 ;
11385 PyObject * obj2 = 0 ;
11386 char * kwnames[] = {
11387 (char *) "filename",(char *) "image",(char *) "type", NULL
11388 };
11389
11390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11391 {
11392 arg1 = wxString_in_helper(obj0);
11393 if (arg1 == NULL) SWIG_fail;
11394 temp1 = true;
11395 }
11396 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11397 if (!SWIG_IsOK(res2)) {
11398 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11399 }
11400 if (!argp2) {
11401 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11402 }
11403 arg2 = reinterpret_cast< wxImage * >(argp2);
11404 ecode3 = SWIG_AsVal_long(obj2, &val3);
11405 if (!SWIG_IsOK(ecode3)) {
11406 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11407 }
11408 arg3 = static_cast< long >(val3);
11409 {
11410 PyThreadState* __tstate = wxPyBeginAllowThreads();
11411 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11412 wxPyEndAllowThreads(__tstate);
11413 if (PyErr_Occurred()) SWIG_fail;
11414 }
11415 resultobj = SWIG_Py_Void();
11416 {
11417 if (temp1)
11418 delete arg1;
11419 }
11420 return resultobj;
11421 fail:
11422 {
11423 if (temp1)
11424 delete arg1;
11425 }
11426 return NULL;
11427 }
11428
11429
11430 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11431 PyObject *resultobj = 0;
11432 wxString *arg1 = 0 ;
11433 wxBitmap *arg2 = 0 ;
11434 long arg3 ;
11435 bool temp1 = false ;
11436 void *argp2 = 0 ;
11437 int res2 = 0 ;
11438 long val3 ;
11439 int ecode3 = 0 ;
11440 PyObject * obj0 = 0 ;
11441 PyObject * obj1 = 0 ;
11442 PyObject * obj2 = 0 ;
11443 char * kwnames[] = {
11444 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11445 };
11446
11447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11448 {
11449 arg1 = wxString_in_helper(obj0);
11450 if (arg1 == NULL) SWIG_fail;
11451 temp1 = true;
11452 }
11453 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11454 if (!SWIG_IsOK(res2)) {
11455 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11456 }
11457 if (!argp2) {
11458 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11459 }
11460 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11461 ecode3 = SWIG_AsVal_long(obj2, &val3);
11462 if (!SWIG_IsOK(ecode3)) {
11463 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11464 }
11465 arg3 = static_cast< long >(val3);
11466 {
11467 PyThreadState* __tstate = wxPyBeginAllowThreads();
11468 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11469 wxPyEndAllowThreads(__tstate);
11470 if (PyErr_Occurred()) SWIG_fail;
11471 }
11472 resultobj = SWIG_Py_Void();
11473 {
11474 if (temp1)
11475 delete arg1;
11476 }
11477 return resultobj;
11478 fail:
11479 {
11480 if (temp1)
11481 delete arg1;
11482 }
11483 return NULL;
11484 }
11485
11486
11487 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11488 PyObject *resultobj = 0;
11489 wxString *arg1 = 0 ;
11490 PyObject *arg2 = (PyObject *) 0 ;
11491 bool temp1 = false ;
11492 PyObject * obj0 = 0 ;
11493 PyObject * obj1 = 0 ;
11494 char * kwnames[] = {
11495 (char *) "filename",(char *) "data", NULL
11496 };
11497
11498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11499 {
11500 arg1 = wxString_in_helper(obj0);
11501 if (arg1 == NULL) SWIG_fail;
11502 temp1 = true;
11503 }
11504 arg2 = obj1;
11505 {
11506 PyThreadState* __tstate = wxPyBeginAllowThreads();
11507 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11508 wxPyEndAllowThreads(__tstate);
11509 if (PyErr_Occurred()) SWIG_fail;
11510 }
11511 resultobj = SWIG_Py_Void();
11512 {
11513 if (temp1)
11514 delete arg1;
11515 }
11516 return resultobj;
11517 fail:
11518 {
11519 if (temp1)
11520 delete arg1;
11521 }
11522 return NULL;
11523 }
11524
11525
11526 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11527 PyObject *resultobj = 0;
11528 wxMemoryFSHandler *result = 0 ;
11529
11530 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11531 {
11532 PyThreadState* __tstate = wxPyBeginAllowThreads();
11533 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11534 wxPyEndAllowThreads(__tstate);
11535 if (PyErr_Occurred()) SWIG_fail;
11536 }
11537 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11538 return resultobj;
11539 fail:
11540 return NULL;
11541 }
11542
11543
11544 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11545 PyObject *resultobj = 0;
11546 wxString *arg1 = 0 ;
11547 bool temp1 = false ;
11548 PyObject * obj0 = 0 ;
11549 char * kwnames[] = {
11550 (char *) "filename", NULL
11551 };
11552
11553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11554 {
11555 arg1 = wxString_in_helper(obj0);
11556 if (arg1 == NULL) SWIG_fail;
11557 temp1 = true;
11558 }
11559 {
11560 PyThreadState* __tstate = wxPyBeginAllowThreads();
11561 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11562 wxPyEndAllowThreads(__tstate);
11563 if (PyErr_Occurred()) SWIG_fail;
11564 }
11565 resultobj = SWIG_Py_Void();
11566 {
11567 if (temp1)
11568 delete arg1;
11569 }
11570 return resultobj;
11571 fail:
11572 {
11573 if (temp1)
11574 delete arg1;
11575 }
11576 return NULL;
11577 }
11578
11579
11580 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11581 PyObject *resultobj = 0;
11582 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11583 wxString *arg2 = 0 ;
11584 bool result;
11585 void *argp1 = 0 ;
11586 int res1 = 0 ;
11587 bool temp2 = false ;
11588 PyObject * obj0 = 0 ;
11589 PyObject * obj1 = 0 ;
11590 char * kwnames[] = {
11591 (char *) "self",(char *) "location", NULL
11592 };
11593
11594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11596 if (!SWIG_IsOK(res1)) {
11597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11598 }
11599 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11600 {
11601 arg2 = wxString_in_helper(obj1);
11602 if (arg2 == NULL) SWIG_fail;
11603 temp2 = true;
11604 }
11605 {
11606 PyThreadState* __tstate = wxPyBeginAllowThreads();
11607 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11608 wxPyEndAllowThreads(__tstate);
11609 if (PyErr_Occurred()) SWIG_fail;
11610 }
11611 {
11612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11613 }
11614 {
11615 if (temp2)
11616 delete arg2;
11617 }
11618 return resultobj;
11619 fail:
11620 {
11621 if (temp2)
11622 delete arg2;
11623 }
11624 return NULL;
11625 }
11626
11627
11628 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11629 PyObject *resultobj = 0;
11630 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11631 wxFileSystem *arg2 = 0 ;
11632 wxString *arg3 = 0 ;
11633 wxFSFile *result = 0 ;
11634 void *argp1 = 0 ;
11635 int res1 = 0 ;
11636 void *argp2 = 0 ;
11637 int res2 = 0 ;
11638 bool temp3 = false ;
11639 PyObject * obj0 = 0 ;
11640 PyObject * obj1 = 0 ;
11641 PyObject * obj2 = 0 ;
11642 char * kwnames[] = {
11643 (char *) "self",(char *) "fs",(char *) "location", NULL
11644 };
11645
11646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11648 if (!SWIG_IsOK(res1)) {
11649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11650 }
11651 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11652 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11653 if (!SWIG_IsOK(res2)) {
11654 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11655 }
11656 if (!argp2) {
11657 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11658 }
11659 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11660 {
11661 arg3 = wxString_in_helper(obj2);
11662 if (arg3 == NULL) SWIG_fail;
11663 temp3 = true;
11664 }
11665 {
11666 PyThreadState* __tstate = wxPyBeginAllowThreads();
11667 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11668 wxPyEndAllowThreads(__tstate);
11669 if (PyErr_Occurred()) SWIG_fail;
11670 }
11671 {
11672 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11673 }
11674 {
11675 if (temp3)
11676 delete arg3;
11677 }
11678 return resultobj;
11679 fail:
11680 {
11681 if (temp3)
11682 delete arg3;
11683 }
11684 return NULL;
11685 }
11686
11687
11688 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11689 PyObject *resultobj = 0;
11690 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11691 wxString *arg2 = 0 ;
11692 int arg3 = (int) 0 ;
11693 wxString result;
11694 void *argp1 = 0 ;
11695 int res1 = 0 ;
11696 bool temp2 = false ;
11697 int val3 ;
11698 int ecode3 = 0 ;
11699 PyObject * obj0 = 0 ;
11700 PyObject * obj1 = 0 ;
11701 PyObject * obj2 = 0 ;
11702 char * kwnames[] = {
11703 (char *) "self",(char *) "spec",(char *) "flags", NULL
11704 };
11705
11706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11708 if (!SWIG_IsOK(res1)) {
11709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11710 }
11711 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11712 {
11713 arg2 = wxString_in_helper(obj1);
11714 if (arg2 == NULL) SWIG_fail;
11715 temp2 = true;
11716 }
11717 if (obj2) {
11718 ecode3 = SWIG_AsVal_int(obj2, &val3);
11719 if (!SWIG_IsOK(ecode3)) {
11720 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11721 }
11722 arg3 = static_cast< int >(val3);
11723 }
11724 {
11725 PyThreadState* __tstate = wxPyBeginAllowThreads();
11726 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11727 wxPyEndAllowThreads(__tstate);
11728 if (PyErr_Occurred()) SWIG_fail;
11729 }
11730 {
11731 #if wxUSE_UNICODE
11732 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11733 #else
11734 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11735 #endif
11736 }
11737 {
11738 if (temp2)
11739 delete arg2;
11740 }
11741 return resultobj;
11742 fail:
11743 {
11744 if (temp2)
11745 delete arg2;
11746 }
11747 return NULL;
11748 }
11749
11750
11751 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11752 PyObject *resultobj = 0;
11753 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11754 wxString result;
11755 void *argp1 = 0 ;
11756 int res1 = 0 ;
11757 PyObject *swig_obj[1] ;
11758
11759 if (!args) SWIG_fail;
11760 swig_obj[0] = args;
11761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11762 if (!SWIG_IsOK(res1)) {
11763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11764 }
11765 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11766 {
11767 PyThreadState* __tstate = wxPyBeginAllowThreads();
11768 result = (arg1)->FindNext();
11769 wxPyEndAllowThreads(__tstate);
11770 if (PyErr_Occurred()) SWIG_fail;
11771 }
11772 {
11773 #if wxUSE_UNICODE
11774 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11775 #else
11776 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11777 #endif
11778 }
11779 return resultobj;
11780 fail:
11781 return NULL;
11782 }
11783
11784
11785 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11786 PyObject *obj;
11787 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11788 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
11789 return SWIG_Py_Void();
11790 }
11791
11792 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11793 return SWIG_Python_InitShadowInstance(args);
11794 }
11795
11796 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11797 PyObject *resultobj = 0;
11798 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11799 wxString result;
11800 void *argp1 = 0 ;
11801 int res1 = 0 ;
11802 PyObject *swig_obj[1] ;
11803
11804 if (!args) SWIG_fail;
11805 swig_obj[0] = args;
11806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11807 if (!SWIG_IsOK(res1)) {
11808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11809 }
11810 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11811 {
11812 PyThreadState* __tstate = wxPyBeginAllowThreads();
11813 result = (arg1)->GetName();
11814 wxPyEndAllowThreads(__tstate);
11815 if (PyErr_Occurred()) SWIG_fail;
11816 }
11817 {
11818 #if wxUSE_UNICODE
11819 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11820 #else
11821 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11822 #endif
11823 }
11824 return resultobj;
11825 fail:
11826 return NULL;
11827 }
11828
11829
11830 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11831 PyObject *resultobj = 0;
11832 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11833 wxString result;
11834 void *argp1 = 0 ;
11835 int res1 = 0 ;
11836 PyObject *swig_obj[1] ;
11837
11838 if (!args) SWIG_fail;
11839 swig_obj[0] = args;
11840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11841 if (!SWIG_IsOK(res1)) {
11842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11843 }
11844 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11845 {
11846 PyThreadState* __tstate = wxPyBeginAllowThreads();
11847 result = (arg1)->GetExtension();
11848 wxPyEndAllowThreads(__tstate);
11849 if (PyErr_Occurred()) SWIG_fail;
11850 }
11851 {
11852 #if wxUSE_UNICODE
11853 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11854 #else
11855 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11856 #endif
11857 }
11858 return resultobj;
11859 fail:
11860 return NULL;
11861 }
11862
11863
11864 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11865 PyObject *resultobj = 0;
11866 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11867 long result;
11868 void *argp1 = 0 ;
11869 int res1 = 0 ;
11870 PyObject *swig_obj[1] ;
11871
11872 if (!args) SWIG_fail;
11873 swig_obj[0] = args;
11874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11875 if (!SWIG_IsOK(res1)) {
11876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11877 }
11878 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11879 {
11880 PyThreadState* __tstate = wxPyBeginAllowThreads();
11881 result = (long)(arg1)->GetType();
11882 wxPyEndAllowThreads(__tstate);
11883 if (PyErr_Occurred()) SWIG_fail;
11884 }
11885 resultobj = SWIG_From_long(static_cast< long >(result));
11886 return resultobj;
11887 fail:
11888 return NULL;
11889 }
11890
11891
11892 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11893 PyObject *resultobj = 0;
11894 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11895 wxString result;
11896 void *argp1 = 0 ;
11897 int res1 = 0 ;
11898 PyObject *swig_obj[1] ;
11899
11900 if (!args) SWIG_fail;
11901 swig_obj[0] = args;
11902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11903 if (!SWIG_IsOK(res1)) {
11904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11905 }
11906 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11907 {
11908 PyThreadState* __tstate = wxPyBeginAllowThreads();
11909 result = (arg1)->GetMimeType();
11910 wxPyEndAllowThreads(__tstate);
11911 if (PyErr_Occurred()) SWIG_fail;
11912 }
11913 {
11914 #if wxUSE_UNICODE
11915 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11916 #else
11917 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11918 #endif
11919 }
11920 return resultobj;
11921 fail:
11922 return NULL;
11923 }
11924
11925
11926 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11927 PyObject *resultobj = 0;
11928 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11929 wxString *arg2 = 0 ;
11930 bool result;
11931 void *argp1 = 0 ;
11932 int res1 = 0 ;
11933 bool temp2 = false ;
11934 PyObject * obj0 = 0 ;
11935 PyObject * obj1 = 0 ;
11936 char * kwnames[] = {
11937 (char *) "self",(char *) "name", NULL
11938 };
11939
11940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
11941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11942 if (!SWIG_IsOK(res1)) {
11943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11944 }
11945 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11946 {
11947 arg2 = wxString_in_helper(obj1);
11948 if (arg2 == NULL) SWIG_fail;
11949 temp2 = true;
11950 }
11951 {
11952 PyThreadState* __tstate = wxPyBeginAllowThreads();
11953 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
11954 wxPyEndAllowThreads(__tstate);
11955 if (PyErr_Occurred()) SWIG_fail;
11956 }
11957 {
11958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11959 }
11960 {
11961 if (temp2)
11962 delete arg2;
11963 }
11964 return resultobj;
11965 fail:
11966 {
11967 if (temp2)
11968 delete arg2;
11969 }
11970 return NULL;
11971 }
11972
11973
11974 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11975 PyObject *resultobj = 0;
11976 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11977 wxInputStream *arg2 = 0 ;
11978 bool result;
11979 void *argp1 = 0 ;
11980 int res1 = 0 ;
11981 wxPyInputStream *temp2 ;
11982 bool created2 ;
11983 PyObject * obj0 = 0 ;
11984 PyObject * obj1 = 0 ;
11985 char * kwnames[] = {
11986 (char *) "self",(char *) "stream", NULL
11987 };
11988
11989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
11990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11991 if (!SWIG_IsOK(res1)) {
11992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11993 }
11994 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11995 {
11996 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11997 arg2 = temp2->m_wxis;
11998 created2 = false;
11999 } else {
12000 PyErr_Clear(); // clear the failure of the wxPyConvert above
12001 arg2 = wxPyCBInputStream_create(obj1, false);
12002 if (arg2 == NULL) {
12003 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12004 SWIG_fail;
12005 }
12006 created2 = true;
12007 }
12008 }
12009 {
12010 PyThreadState* __tstate = wxPyBeginAllowThreads();
12011 result = (bool)(arg1)->CanRead(*arg2);
12012 wxPyEndAllowThreads(__tstate);
12013 if (PyErr_Occurred()) SWIG_fail;
12014 }
12015 {
12016 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12017 }
12018 {
12019 if (created2) delete arg2;
12020 }
12021 return resultobj;
12022 fail:
12023 {
12024 if (created2) delete arg2;
12025 }
12026 return NULL;
12027 }
12028
12029
12030 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12031 PyObject *resultobj = 0;
12032 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12033 wxString *arg2 = 0 ;
12034 void *argp1 = 0 ;
12035 int res1 = 0 ;
12036 bool temp2 = false ;
12037 PyObject * obj0 = 0 ;
12038 PyObject * obj1 = 0 ;
12039 char * kwnames[] = {
12040 (char *) "self",(char *) "name", NULL
12041 };
12042
12043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
12044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12045 if (!SWIG_IsOK(res1)) {
12046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12047 }
12048 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12049 {
12050 arg2 = wxString_in_helper(obj1);
12051 if (arg2 == NULL) SWIG_fail;
12052 temp2 = true;
12053 }
12054 {
12055 PyThreadState* __tstate = wxPyBeginAllowThreads();
12056 (arg1)->SetName((wxString const &)*arg2);
12057 wxPyEndAllowThreads(__tstate);
12058 if (PyErr_Occurred()) SWIG_fail;
12059 }
12060 resultobj = SWIG_Py_Void();
12061 {
12062 if (temp2)
12063 delete arg2;
12064 }
12065 return resultobj;
12066 fail:
12067 {
12068 if (temp2)
12069 delete arg2;
12070 }
12071 return NULL;
12072 }
12073
12074
12075 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12076 PyObject *resultobj = 0;
12077 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12078 wxString *arg2 = 0 ;
12079 void *argp1 = 0 ;
12080 int res1 = 0 ;
12081 bool temp2 = false ;
12082 PyObject * obj0 = 0 ;
12083 PyObject * obj1 = 0 ;
12084 char * kwnames[] = {
12085 (char *) "self",(char *) "extension", NULL
12086 };
12087
12088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
12089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12090 if (!SWIG_IsOK(res1)) {
12091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12092 }
12093 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12094 {
12095 arg2 = wxString_in_helper(obj1);
12096 if (arg2 == NULL) SWIG_fail;
12097 temp2 = true;
12098 }
12099 {
12100 PyThreadState* __tstate = wxPyBeginAllowThreads();
12101 (arg1)->SetExtension((wxString const &)*arg2);
12102 wxPyEndAllowThreads(__tstate);
12103 if (PyErr_Occurred()) SWIG_fail;
12104 }
12105 resultobj = SWIG_Py_Void();
12106 {
12107 if (temp2)
12108 delete arg2;
12109 }
12110 return resultobj;
12111 fail:
12112 {
12113 if (temp2)
12114 delete arg2;
12115 }
12116 return NULL;
12117 }
12118
12119
12120 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12121 PyObject *resultobj = 0;
12122 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12123 long arg2 ;
12124 void *argp1 = 0 ;
12125 int res1 = 0 ;
12126 long val2 ;
12127 int ecode2 = 0 ;
12128 PyObject * obj0 = 0 ;
12129 PyObject * obj1 = 0 ;
12130 char * kwnames[] = {
12131 (char *) "self",(char *) "type", NULL
12132 };
12133
12134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
12135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12136 if (!SWIG_IsOK(res1)) {
12137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12138 }
12139 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12140 ecode2 = SWIG_AsVal_long(obj1, &val2);
12141 if (!SWIG_IsOK(ecode2)) {
12142 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
12143 }
12144 arg2 = static_cast< long >(val2);
12145 {
12146 PyThreadState* __tstate = wxPyBeginAllowThreads();
12147 (arg1)->SetType(arg2);
12148 wxPyEndAllowThreads(__tstate);
12149 if (PyErr_Occurred()) SWIG_fail;
12150 }
12151 resultobj = SWIG_Py_Void();
12152 return resultobj;
12153 fail:
12154 return NULL;
12155 }
12156
12157
12158 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12159 PyObject *resultobj = 0;
12160 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12161 wxString *arg2 = 0 ;
12162 void *argp1 = 0 ;
12163 int res1 = 0 ;
12164 bool temp2 = false ;
12165 PyObject * obj0 = 0 ;
12166 PyObject * obj1 = 0 ;
12167 char * kwnames[] = {
12168 (char *) "self",(char *) "mimetype", NULL
12169 };
12170
12171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
12172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12173 if (!SWIG_IsOK(res1)) {
12174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12175 }
12176 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12177 {
12178 arg2 = wxString_in_helper(obj1);
12179 if (arg2 == NULL) SWIG_fail;
12180 temp2 = true;
12181 }
12182 {
12183 PyThreadState* __tstate = wxPyBeginAllowThreads();
12184 (arg1)->SetMimeType((wxString const &)*arg2);
12185 wxPyEndAllowThreads(__tstate);
12186 if (PyErr_Occurred()) SWIG_fail;
12187 }
12188 resultobj = SWIG_Py_Void();
12189 {
12190 if (temp2)
12191 delete arg2;
12192 }
12193 return resultobj;
12194 fail:
12195 {
12196 if (temp2)
12197 delete arg2;
12198 }
12199 return NULL;
12200 }
12201
12202
12203 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12204 PyObject *obj;
12205 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12206 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12207 return SWIG_Py_Void();
12208 }
12209
12210 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12211 PyObject *resultobj = 0;
12212 wxPyImageHandler *result = 0 ;
12213
12214 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12215 {
12216 PyThreadState* __tstate = wxPyBeginAllowThreads();
12217 result = (wxPyImageHandler *)new wxPyImageHandler();
12218 wxPyEndAllowThreads(__tstate);
12219 if (PyErr_Occurred()) SWIG_fail;
12220 }
12221 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12222 return resultobj;
12223 fail:
12224 return NULL;
12225 }
12226
12227
12228 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12229 PyObject *resultobj = 0;
12230 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12231 PyObject *arg2 = (PyObject *) 0 ;
12232 void *argp1 = 0 ;
12233 int res1 = 0 ;
12234 PyObject * obj0 = 0 ;
12235 PyObject * obj1 = 0 ;
12236 char * kwnames[] = {
12237 (char *) "self",(char *) "self", NULL
12238 };
12239
12240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12242 if (!SWIG_IsOK(res1)) {
12243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12244 }
12245 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12246 arg2 = obj1;
12247 {
12248 PyThreadState* __tstate = wxPyBeginAllowThreads();
12249 (arg1)->_SetSelf(arg2);
12250 wxPyEndAllowThreads(__tstate);
12251 if (PyErr_Occurred()) SWIG_fail;
12252 }
12253 resultobj = SWIG_Py_Void();
12254 return resultobj;
12255 fail:
12256 return NULL;
12257 }
12258
12259
12260 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12261 PyObject *obj;
12262 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12263 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12264 return SWIG_Py_Void();
12265 }
12266
12267 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12268 return SWIG_Python_InitShadowInstance(args);
12269 }
12270
12271 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12272 PyObject *resultobj = 0;
12273 wxImageHistogram *result = 0 ;
12274
12275 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12276 {
12277 PyThreadState* __tstate = wxPyBeginAllowThreads();
12278 result = (wxImageHistogram *)new wxImageHistogram();
12279 wxPyEndAllowThreads(__tstate);
12280 if (PyErr_Occurred()) SWIG_fail;
12281 }
12282 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12283 return resultobj;
12284 fail:
12285 return NULL;
12286 }
12287
12288
12289 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12290 PyObject *resultobj = 0;
12291 byte arg1 ;
12292 byte arg2 ;
12293 byte arg3 ;
12294 unsigned long result;
12295 unsigned char val1 ;
12296 int ecode1 = 0 ;
12297 unsigned char val2 ;
12298 int ecode2 = 0 ;
12299 unsigned char val3 ;
12300 int ecode3 = 0 ;
12301 PyObject * obj0 = 0 ;
12302 PyObject * obj1 = 0 ;
12303 PyObject * obj2 = 0 ;
12304 char * kwnames[] = {
12305 (char *) "r",(char *) "g",(char *) "b", NULL
12306 };
12307
12308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12309 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12310 if (!SWIG_IsOK(ecode1)) {
12311 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12312 }
12313 arg1 = static_cast< byte >(val1);
12314 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12315 if (!SWIG_IsOK(ecode2)) {
12316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12317 }
12318 arg2 = static_cast< byte >(val2);
12319 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12320 if (!SWIG_IsOK(ecode3)) {
12321 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12322 }
12323 arg3 = static_cast< byte >(val3);
12324 {
12325 PyThreadState* __tstate = wxPyBeginAllowThreads();
12326 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12327 wxPyEndAllowThreads(__tstate);
12328 if (PyErr_Occurred()) SWIG_fail;
12329 }
12330 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12331 return resultobj;
12332 fail:
12333 return NULL;
12334 }
12335
12336
12337 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12338 PyObject *resultobj = 0;
12339 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12340 byte *arg2 = (byte *) 0 ;
12341 byte *arg3 = (byte *) 0 ;
12342 byte *arg4 = (byte *) 0 ;
12343 byte arg5 = (byte) 1 ;
12344 byte arg6 = (byte) 0 ;
12345 byte arg7 = (byte) 0 ;
12346 bool result;
12347 void *argp1 = 0 ;
12348 int res1 = 0 ;
12349 byte temp2 ;
12350 int res2 = SWIG_TMPOBJ ;
12351 byte temp3 ;
12352 int res3 = SWIG_TMPOBJ ;
12353 byte temp4 ;
12354 int res4 = SWIG_TMPOBJ ;
12355 unsigned char val5 ;
12356 int ecode5 = 0 ;
12357 unsigned char val6 ;
12358 int ecode6 = 0 ;
12359 unsigned char val7 ;
12360 int ecode7 = 0 ;
12361 PyObject * obj0 = 0 ;
12362 PyObject * obj1 = 0 ;
12363 PyObject * obj2 = 0 ;
12364 PyObject * obj3 = 0 ;
12365 char * kwnames[] = {
12366 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12367 };
12368
12369 arg2 = &temp2;
12370 arg3 = &temp3;
12371 arg4 = &temp4;
12372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12374 if (!SWIG_IsOK(res1)) {
12375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12376 }
12377 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12378 if (obj1) {
12379 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12380 if (!SWIG_IsOK(ecode5)) {
12381 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12382 }
12383 arg5 = static_cast< byte >(val5);
12384 }
12385 if (obj2) {
12386 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12387 if (!SWIG_IsOK(ecode6)) {
12388 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12389 }
12390 arg6 = static_cast< byte >(val6);
12391 }
12392 if (obj3) {
12393 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12394 if (!SWIG_IsOK(ecode7)) {
12395 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12396 }
12397 arg7 = static_cast< byte >(val7);
12398 }
12399 {
12400 PyThreadState* __tstate = wxPyBeginAllowThreads();
12401 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12402 wxPyEndAllowThreads(__tstate);
12403 if (PyErr_Occurred()) SWIG_fail;
12404 }
12405 {
12406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12407 }
12408 if (SWIG_IsTmpObj(res2)) {
12409 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12410 } else {
12411 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12412 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12413 }
12414 if (SWIG_IsTmpObj(res3)) {
12415 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12416 } else {
12417 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12418 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12419 }
12420 if (SWIG_IsTmpObj(res4)) {
12421 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12422 } else {
12423 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12424 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12425 }
12426 return resultobj;
12427 fail:
12428 return NULL;
12429 }
12430
12431
12432 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12433 PyObject *resultobj = 0;
12434 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12435 unsigned long arg2 ;
12436 unsigned long result;
12437 void *argp1 = 0 ;
12438 int res1 = 0 ;
12439 unsigned long val2 ;
12440 int ecode2 = 0 ;
12441 PyObject * obj0 = 0 ;
12442 PyObject * obj1 = 0 ;
12443 char * kwnames[] = {
12444 (char *) "self",(char *) "key", NULL
12445 };
12446
12447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12449 if (!SWIG_IsOK(res1)) {
12450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12451 }
12452 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12453 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12454 if (!SWIG_IsOK(ecode2)) {
12455 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12456 }
12457 arg2 = static_cast< unsigned long >(val2);
12458 {
12459 PyThreadState* __tstate = wxPyBeginAllowThreads();
12460 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12461 wxPyEndAllowThreads(__tstate);
12462 if (PyErr_Occurred()) SWIG_fail;
12463 }
12464 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12465 return resultobj;
12466 fail:
12467 return NULL;
12468 }
12469
12470
12471 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12472 PyObject *resultobj = 0;
12473 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12474 byte arg2 ;
12475 byte arg3 ;
12476 byte arg4 ;
12477 unsigned long result;
12478 void *argp1 = 0 ;
12479 int res1 = 0 ;
12480 unsigned char val2 ;
12481 int ecode2 = 0 ;
12482 unsigned char val3 ;
12483 int ecode3 = 0 ;
12484 unsigned char val4 ;
12485 int ecode4 = 0 ;
12486 PyObject * obj0 = 0 ;
12487 PyObject * obj1 = 0 ;
12488 PyObject * obj2 = 0 ;
12489 PyObject * obj3 = 0 ;
12490 char * kwnames[] = {
12491 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12492 };
12493
12494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12496 if (!SWIG_IsOK(res1)) {
12497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12498 }
12499 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12500 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12501 if (!SWIG_IsOK(ecode2)) {
12502 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12503 }
12504 arg2 = static_cast< byte >(val2);
12505 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12506 if (!SWIG_IsOK(ecode3)) {
12507 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12508 }
12509 arg3 = static_cast< byte >(val3);
12510 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12511 if (!SWIG_IsOK(ecode4)) {
12512 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12513 }
12514 arg4 = static_cast< byte >(val4);
12515 {
12516 PyThreadState* __tstate = wxPyBeginAllowThreads();
12517 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12518 wxPyEndAllowThreads(__tstate);
12519 if (PyErr_Occurred()) SWIG_fail;
12520 }
12521 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12522 return resultobj;
12523 fail:
12524 return NULL;
12525 }
12526
12527
12528 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12529 PyObject *resultobj = 0;
12530 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12531 wxColour *arg2 = 0 ;
12532 unsigned long result;
12533 void *argp1 = 0 ;
12534 int res1 = 0 ;
12535 wxColour temp2 ;
12536 PyObject * obj0 = 0 ;
12537 PyObject * obj1 = 0 ;
12538 char * kwnames[] = {
12539 (char *) "self",(char *) "colour", NULL
12540 };
12541
12542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12544 if (!SWIG_IsOK(res1)) {
12545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12546 }
12547 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12548 {
12549 arg2 = &temp2;
12550 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12551 }
12552 {
12553 PyThreadState* __tstate = wxPyBeginAllowThreads();
12554 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12555 wxPyEndAllowThreads(__tstate);
12556 if (PyErr_Occurred()) SWIG_fail;
12557 }
12558 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12559 return resultobj;
12560 fail:
12561 return NULL;
12562 }
12563
12564
12565 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12566 PyObject *obj;
12567 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12568 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12569 return SWIG_Py_Void();
12570 }
12571
12572 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12573 return SWIG_Python_InitShadowInstance(args);
12574 }
12575
12576 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12577 PyObject *resultobj = 0;
12578 byte arg1 = (byte) 0 ;
12579 byte arg2 = (byte) 0 ;
12580 byte arg3 = (byte) 0 ;
12581 wxImage_RGBValue *result = 0 ;
12582 unsigned char val1 ;
12583 int ecode1 = 0 ;
12584 unsigned char val2 ;
12585 int ecode2 = 0 ;
12586 unsigned char val3 ;
12587 int ecode3 = 0 ;
12588 PyObject * obj0 = 0 ;
12589 PyObject * obj1 = 0 ;
12590 PyObject * obj2 = 0 ;
12591 char * kwnames[] = {
12592 (char *) "r",(char *) "g",(char *) "b", NULL
12593 };
12594
12595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12596 if (obj0) {
12597 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12598 if (!SWIG_IsOK(ecode1)) {
12599 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12600 }
12601 arg1 = static_cast< byte >(val1);
12602 }
12603 if (obj1) {
12604 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12605 if (!SWIG_IsOK(ecode2)) {
12606 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12607 }
12608 arg2 = static_cast< byte >(val2);
12609 }
12610 if (obj2) {
12611 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12612 if (!SWIG_IsOK(ecode3)) {
12613 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12614 }
12615 arg3 = static_cast< byte >(val3);
12616 }
12617 {
12618 PyThreadState* __tstate = wxPyBeginAllowThreads();
12619 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12620 wxPyEndAllowThreads(__tstate);
12621 if (PyErr_Occurred()) SWIG_fail;
12622 }
12623 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12624 return resultobj;
12625 fail:
12626 return NULL;
12627 }
12628
12629
12630 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12631 PyObject *resultobj = 0;
12632 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12633 byte arg2 ;
12634 void *argp1 = 0 ;
12635 int res1 = 0 ;
12636 unsigned char val2 ;
12637 int ecode2 = 0 ;
12638 PyObject *swig_obj[2] ;
12639
12640 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12642 if (!SWIG_IsOK(res1)) {
12643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12644 }
12645 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12646 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12647 if (!SWIG_IsOK(ecode2)) {
12648 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12649 }
12650 arg2 = static_cast< byte >(val2);
12651 if (arg1) (arg1)->red = arg2;
12652
12653 resultobj = SWIG_Py_Void();
12654 return resultobj;
12655 fail:
12656 return NULL;
12657 }
12658
12659
12660 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12661 PyObject *resultobj = 0;
12662 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12663 byte result;
12664 void *argp1 = 0 ;
12665 int res1 = 0 ;
12666 PyObject *swig_obj[1] ;
12667
12668 if (!args) SWIG_fail;
12669 swig_obj[0] = args;
12670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12671 if (!SWIG_IsOK(res1)) {
12672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12673 }
12674 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12675 result = (byte) ((arg1)->red);
12676 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12677 return resultobj;
12678 fail:
12679 return NULL;
12680 }
12681
12682
12683 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12684 PyObject *resultobj = 0;
12685 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12686 byte arg2 ;
12687 void *argp1 = 0 ;
12688 int res1 = 0 ;
12689 unsigned char val2 ;
12690 int ecode2 = 0 ;
12691 PyObject *swig_obj[2] ;
12692
12693 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12695 if (!SWIG_IsOK(res1)) {
12696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12697 }
12698 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12699 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12700 if (!SWIG_IsOK(ecode2)) {
12701 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12702 }
12703 arg2 = static_cast< byte >(val2);
12704 if (arg1) (arg1)->green = arg2;
12705
12706 resultobj = SWIG_Py_Void();
12707 return resultobj;
12708 fail:
12709 return NULL;
12710 }
12711
12712
12713 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12714 PyObject *resultobj = 0;
12715 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12716 byte result;
12717 void *argp1 = 0 ;
12718 int res1 = 0 ;
12719 PyObject *swig_obj[1] ;
12720
12721 if (!args) SWIG_fail;
12722 swig_obj[0] = args;
12723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12724 if (!SWIG_IsOK(res1)) {
12725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12726 }
12727 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12728 result = (byte) ((arg1)->green);
12729 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12730 return resultobj;
12731 fail:
12732 return NULL;
12733 }
12734
12735
12736 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12737 PyObject *resultobj = 0;
12738 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12739 byte arg2 ;
12740 void *argp1 = 0 ;
12741 int res1 = 0 ;
12742 unsigned char val2 ;
12743 int ecode2 = 0 ;
12744 PyObject *swig_obj[2] ;
12745
12746 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
12747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12748 if (!SWIG_IsOK(res1)) {
12749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12750 }
12751 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12752 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12753 if (!SWIG_IsOK(ecode2)) {
12754 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
12755 }
12756 arg2 = static_cast< byte >(val2);
12757 if (arg1) (arg1)->blue = arg2;
12758
12759 resultobj = SWIG_Py_Void();
12760 return resultobj;
12761 fail:
12762 return NULL;
12763 }
12764
12765
12766 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12767 PyObject *resultobj = 0;
12768 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12769 byte result;
12770 void *argp1 = 0 ;
12771 int res1 = 0 ;
12772 PyObject *swig_obj[1] ;
12773
12774 if (!args) SWIG_fail;
12775 swig_obj[0] = args;
12776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12777 if (!SWIG_IsOK(res1)) {
12778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12779 }
12780 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12781 result = (byte) ((arg1)->blue);
12782 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12783 return resultobj;
12784 fail:
12785 return NULL;
12786 }
12787
12788
12789 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12790 PyObject *obj;
12791 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12792 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
12793 return SWIG_Py_Void();
12794 }
12795
12796 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12797 return SWIG_Python_InitShadowInstance(args);
12798 }
12799
12800 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12801 PyObject *resultobj = 0;
12802 double arg1 = (double) 0.0 ;
12803 double arg2 = (double) 0.0 ;
12804 double arg3 = (double) 0.0 ;
12805 wxImage_HSVValue *result = 0 ;
12806 double val1 ;
12807 int ecode1 = 0 ;
12808 double val2 ;
12809 int ecode2 = 0 ;
12810 double val3 ;
12811 int ecode3 = 0 ;
12812 PyObject * obj0 = 0 ;
12813 PyObject * obj1 = 0 ;
12814 PyObject * obj2 = 0 ;
12815 char * kwnames[] = {
12816 (char *) "h",(char *) "s",(char *) "v", NULL
12817 };
12818
12819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12820 if (obj0) {
12821 ecode1 = SWIG_AsVal_double(obj0, &val1);
12822 if (!SWIG_IsOK(ecode1)) {
12823 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
12824 }
12825 arg1 = static_cast< double >(val1);
12826 }
12827 if (obj1) {
12828 ecode2 = SWIG_AsVal_double(obj1, &val2);
12829 if (!SWIG_IsOK(ecode2)) {
12830 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
12831 }
12832 arg2 = static_cast< double >(val2);
12833 }
12834 if (obj2) {
12835 ecode3 = SWIG_AsVal_double(obj2, &val3);
12836 if (!SWIG_IsOK(ecode3)) {
12837 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
12838 }
12839 arg3 = static_cast< double >(val3);
12840 }
12841 {
12842 PyThreadState* __tstate = wxPyBeginAllowThreads();
12843 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
12844 wxPyEndAllowThreads(__tstate);
12845 if (PyErr_Occurred()) SWIG_fail;
12846 }
12847 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
12848 return resultobj;
12849 fail:
12850 return NULL;
12851 }
12852
12853
12854 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12855 PyObject *resultobj = 0;
12856 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12857 double arg2 ;
12858 void *argp1 = 0 ;
12859 int res1 = 0 ;
12860 double val2 ;
12861 int ecode2 = 0 ;
12862 PyObject *swig_obj[2] ;
12863
12864 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
12865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12866 if (!SWIG_IsOK(res1)) {
12867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12868 }
12869 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12870 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12871 if (!SWIG_IsOK(ecode2)) {
12872 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
12873 }
12874 arg2 = static_cast< double >(val2);
12875 if (arg1) (arg1)->hue = arg2;
12876
12877 resultobj = SWIG_Py_Void();
12878 return resultobj;
12879 fail:
12880 return NULL;
12881 }
12882
12883
12884 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12885 PyObject *resultobj = 0;
12886 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12887 double result;
12888 void *argp1 = 0 ;
12889 int res1 = 0 ;
12890 PyObject *swig_obj[1] ;
12891
12892 if (!args) SWIG_fail;
12893 swig_obj[0] = args;
12894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12895 if (!SWIG_IsOK(res1)) {
12896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12897 }
12898 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12899 result = (double) ((arg1)->hue);
12900 resultobj = SWIG_From_double(static_cast< double >(result));
12901 return resultobj;
12902 fail:
12903 return NULL;
12904 }
12905
12906
12907 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12908 PyObject *resultobj = 0;
12909 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12910 double arg2 ;
12911 void *argp1 = 0 ;
12912 int res1 = 0 ;
12913 double val2 ;
12914 int ecode2 = 0 ;
12915 PyObject *swig_obj[2] ;
12916
12917 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
12918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12919 if (!SWIG_IsOK(res1)) {
12920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12921 }
12922 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12923 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12924 if (!SWIG_IsOK(ecode2)) {
12925 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
12926 }
12927 arg2 = static_cast< double >(val2);
12928 if (arg1) (arg1)->saturation = arg2;
12929
12930 resultobj = SWIG_Py_Void();
12931 return resultobj;
12932 fail:
12933 return NULL;
12934 }
12935
12936
12937 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12938 PyObject *resultobj = 0;
12939 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12940 double result;
12941 void *argp1 = 0 ;
12942 int res1 = 0 ;
12943 PyObject *swig_obj[1] ;
12944
12945 if (!args) SWIG_fail;
12946 swig_obj[0] = args;
12947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12948 if (!SWIG_IsOK(res1)) {
12949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12950 }
12951 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12952 result = (double) ((arg1)->saturation);
12953 resultobj = SWIG_From_double(static_cast< double >(result));
12954 return resultobj;
12955 fail:
12956 return NULL;
12957 }
12958
12959
12960 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12961 PyObject *resultobj = 0;
12962 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12963 double arg2 ;
12964 void *argp1 = 0 ;
12965 int res1 = 0 ;
12966 double val2 ;
12967 int ecode2 = 0 ;
12968 PyObject *swig_obj[2] ;
12969
12970 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
12971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12972 if (!SWIG_IsOK(res1)) {
12973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12974 }
12975 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12976 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12977 if (!SWIG_IsOK(ecode2)) {
12978 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
12979 }
12980 arg2 = static_cast< double >(val2);
12981 if (arg1) (arg1)->value = arg2;
12982
12983 resultobj = SWIG_Py_Void();
12984 return resultobj;
12985 fail:
12986 return NULL;
12987 }
12988
12989
12990 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12991 PyObject *resultobj = 0;
12992 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12993 double result;
12994 void *argp1 = 0 ;
12995 int res1 = 0 ;
12996 PyObject *swig_obj[1] ;
12997
12998 if (!args) SWIG_fail;
12999 swig_obj[0] = args;
13000 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13001 if (!SWIG_IsOK(res1)) {
13002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13003 }
13004 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13005 result = (double) ((arg1)->value);
13006 resultobj = SWIG_From_double(static_cast< double >(result));
13007 return resultobj;
13008 fail:
13009 return NULL;
13010 }
13011
13012
13013 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13014 PyObject *obj;
13015 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13016 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
13017 return SWIG_Py_Void();
13018 }
13019
13020 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13021 return SWIG_Python_InitShadowInstance(args);
13022 }
13023
13024 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13025 PyObject *resultobj = 0;
13026 wxString *arg1 = 0 ;
13027 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13028 int arg3 = (int) -1 ;
13029 wxImage *result = 0 ;
13030 bool temp1 = false ;
13031 long val2 ;
13032 int ecode2 = 0 ;
13033 int val3 ;
13034 int ecode3 = 0 ;
13035 PyObject * obj0 = 0 ;
13036 PyObject * obj1 = 0 ;
13037 PyObject * obj2 = 0 ;
13038 char * kwnames[] = {
13039 (char *) "name",(char *) "type",(char *) "index", NULL
13040 };
13041
13042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13043 {
13044 arg1 = wxString_in_helper(obj0);
13045 if (arg1 == NULL) SWIG_fail;
13046 temp1 = true;
13047 }
13048 if (obj1) {
13049 ecode2 = SWIG_AsVal_long(obj1, &val2);
13050 if (!SWIG_IsOK(ecode2)) {
13051 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
13052 }
13053 arg2 = static_cast< long >(val2);
13054 }
13055 if (obj2) {
13056 ecode3 = SWIG_AsVal_int(obj2, &val3);
13057 if (!SWIG_IsOK(ecode3)) {
13058 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
13059 }
13060 arg3 = static_cast< int >(val3);
13061 }
13062 {
13063 PyThreadState* __tstate = wxPyBeginAllowThreads();
13064 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
13065 wxPyEndAllowThreads(__tstate);
13066 if (PyErr_Occurred()) SWIG_fail;
13067 }
13068 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
13069 {
13070 if (temp1)
13071 delete arg1;
13072 }
13073 return resultobj;
13074 fail:
13075 {
13076 if (temp1)
13077 delete arg1;
13078 }
13079 return NULL;
13080 }
13081
13082
13083 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13084 PyObject *resultobj = 0;
13085 wxImage *arg1 = (wxImage *) 0 ;
13086 void *argp1 = 0 ;
13087 int res1 = 0 ;
13088 PyObject *swig_obj[1] ;
13089
13090 if (!args) SWIG_fail;
13091 swig_obj[0] = args;
13092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
13093 if (!SWIG_IsOK(res1)) {
13094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
13095 }
13096 arg1 = reinterpret_cast< wxImage * >(argp1);
13097 {
13098 PyThreadState* __tstate = wxPyBeginAllowThreads();
13099 delete arg1;
13100
13101 wxPyEndAllowThreads(__tstate);
13102 if (PyErr_Occurred()) SWIG_fail;
13103 }
13104 resultobj = SWIG_Py_Void();
13105 return resultobj;
13106 fail:
13107 return NULL;
13108 }
13109
13110
13111 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13112 PyObject *resultobj = 0;
13113 wxString *arg1 = 0 ;
13114 wxString *arg2 = 0 ;
13115 int arg3 = (int) -1 ;
13116 wxImage *result = 0 ;
13117 bool temp1 = false ;
13118 bool temp2 = false ;
13119 int val3 ;
13120 int ecode3 = 0 ;
13121 PyObject * obj0 = 0 ;
13122 PyObject * obj1 = 0 ;
13123 PyObject * obj2 = 0 ;
13124 char * kwnames[] = {
13125 (char *) "name",(char *) "mimetype",(char *) "index", NULL
13126 };
13127
13128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13129 {
13130 arg1 = wxString_in_helper(obj0);
13131 if (arg1 == NULL) SWIG_fail;
13132 temp1 = true;
13133 }
13134 {
13135 arg2 = wxString_in_helper(obj1);
13136 if (arg2 == NULL) SWIG_fail;
13137 temp2 = true;
13138 }
13139 if (obj2) {
13140 ecode3 = SWIG_AsVal_int(obj2, &val3);
13141 if (!SWIG_IsOK(ecode3)) {
13142 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
13143 }
13144 arg3 = static_cast< int >(val3);
13145 }
13146 {
13147 PyThreadState* __tstate = wxPyBeginAllowThreads();
13148 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
13149 wxPyEndAllowThreads(__tstate);
13150 if (PyErr_Occurred()) SWIG_fail;
13151 }
13152 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13153 {
13154 if (temp1)
13155 delete arg1;
13156 }
13157 {
13158 if (temp2)
13159 delete arg2;
13160 }
13161 return resultobj;
13162 fail:
13163 {
13164 if (temp1)
13165 delete arg1;
13166 }
13167 {
13168 if (temp2)
13169 delete arg2;
13170 }
13171 return NULL;
13172 }
13173
13174
13175 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13176 PyObject *resultobj = 0;
13177 wxInputStream *arg1 = 0 ;
13178 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13179 int arg3 = (int) -1 ;
13180 wxImage *result = 0 ;
13181 wxPyInputStream *temp1 ;
13182 bool created1 ;
13183 long val2 ;
13184 int ecode2 = 0 ;
13185 int val3 ;
13186 int ecode3 = 0 ;
13187 PyObject * obj0 = 0 ;
13188 PyObject * obj1 = 0 ;
13189 PyObject * obj2 = 0 ;
13190 char * kwnames[] = {
13191 (char *) "stream",(char *) "type",(char *) "index", NULL
13192 };
13193
13194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13195 {
13196 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13197 arg1 = temp1->m_wxis;
13198 created1 = false;
13199 } else {
13200 PyErr_Clear(); // clear the failure of the wxPyConvert above
13201 arg1 = wxPyCBInputStream_create(obj0, false);
13202 if (arg1 == NULL) {
13203 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13204 SWIG_fail;
13205 }
13206 created1 = true;
13207 }
13208 }
13209 if (obj1) {
13210 ecode2 = SWIG_AsVal_long(obj1, &val2);
13211 if (!SWIG_IsOK(ecode2)) {
13212 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13213 }
13214 arg2 = static_cast< long >(val2);
13215 }
13216 if (obj2) {
13217 ecode3 = SWIG_AsVal_int(obj2, &val3);
13218 if (!SWIG_IsOK(ecode3)) {
13219 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13220 }
13221 arg3 = static_cast< int >(val3);
13222 }
13223 {
13224 PyThreadState* __tstate = wxPyBeginAllowThreads();
13225 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13226 wxPyEndAllowThreads(__tstate);
13227 if (PyErr_Occurred()) SWIG_fail;
13228 }
13229 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13230 {
13231 if (created1) delete arg1;
13232 }
13233 return resultobj;
13234 fail:
13235 {
13236 if (created1) delete arg1;
13237 }
13238 return NULL;
13239 }
13240
13241
13242 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13243 PyObject *resultobj = 0;
13244 wxInputStream *arg1 = 0 ;
13245 wxString *arg2 = 0 ;
13246 int arg3 = (int) -1 ;
13247 wxImage *result = 0 ;
13248 wxPyInputStream *temp1 ;
13249 bool created1 ;
13250 bool temp2 = false ;
13251 int val3 ;
13252 int ecode3 = 0 ;
13253 PyObject * obj0 = 0 ;
13254 PyObject * obj1 = 0 ;
13255 PyObject * obj2 = 0 ;
13256 char * kwnames[] = {
13257 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13258 };
13259
13260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13261 {
13262 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13263 arg1 = temp1->m_wxis;
13264 created1 = false;
13265 } else {
13266 PyErr_Clear(); // clear the failure of the wxPyConvert above
13267 arg1 = wxPyCBInputStream_create(obj0, false);
13268 if (arg1 == NULL) {
13269 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13270 SWIG_fail;
13271 }
13272 created1 = true;
13273 }
13274 }
13275 {
13276 arg2 = wxString_in_helper(obj1);
13277 if (arg2 == NULL) SWIG_fail;
13278 temp2 = true;
13279 }
13280 if (obj2) {
13281 ecode3 = SWIG_AsVal_int(obj2, &val3);
13282 if (!SWIG_IsOK(ecode3)) {
13283 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13284 }
13285 arg3 = static_cast< int >(val3);
13286 }
13287 {
13288 PyThreadState* __tstate = wxPyBeginAllowThreads();
13289 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13290 wxPyEndAllowThreads(__tstate);
13291 if (PyErr_Occurred()) SWIG_fail;
13292 }
13293 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13294 {
13295 if (created1) delete arg1;
13296 }
13297 {
13298 if (temp2)
13299 delete arg2;
13300 }
13301 return resultobj;
13302 fail:
13303 {
13304 if (created1) delete arg1;
13305 }
13306 {
13307 if (temp2)
13308 delete arg2;
13309 }
13310 return NULL;
13311 }
13312
13313
13314 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13315 PyObject *resultobj = 0;
13316 int arg1 = (int) 0 ;
13317 int arg2 = (int) 0 ;
13318 bool arg3 = (bool) true ;
13319 wxImage *result = 0 ;
13320 int val1 ;
13321 int ecode1 = 0 ;
13322 int val2 ;
13323 int ecode2 = 0 ;
13324 bool val3 ;
13325 int ecode3 = 0 ;
13326 PyObject * obj0 = 0 ;
13327 PyObject * obj1 = 0 ;
13328 PyObject * obj2 = 0 ;
13329 char * kwnames[] = {
13330 (char *) "width",(char *) "height",(char *) "clear", NULL
13331 };
13332
13333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13334 if (obj0) {
13335 ecode1 = SWIG_AsVal_int(obj0, &val1);
13336 if (!SWIG_IsOK(ecode1)) {
13337 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13338 }
13339 arg1 = static_cast< int >(val1);
13340 }
13341 if (obj1) {
13342 ecode2 = SWIG_AsVal_int(obj1, &val2);
13343 if (!SWIG_IsOK(ecode2)) {
13344 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13345 }
13346 arg2 = static_cast< int >(val2);
13347 }
13348 if (obj2) {
13349 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13350 if (!SWIG_IsOK(ecode3)) {
13351 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13352 }
13353 arg3 = static_cast< bool >(val3);
13354 }
13355 {
13356 PyThreadState* __tstate = wxPyBeginAllowThreads();
13357 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13358 wxPyEndAllowThreads(__tstate);
13359 if (PyErr_Occurred()) SWIG_fail;
13360 }
13361 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13362 return resultobj;
13363 fail:
13364 return NULL;
13365 }
13366
13367
13368 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13369 PyObject *resultobj = 0;
13370 wxBitmap *arg1 = 0 ;
13371 wxImage *result = 0 ;
13372 void *argp1 = 0 ;
13373 int res1 = 0 ;
13374 PyObject * obj0 = 0 ;
13375 char * kwnames[] = {
13376 (char *) "bitmap", NULL
13377 };
13378
13379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13380 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13381 if (!SWIG_IsOK(res1)) {
13382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13383 }
13384 if (!argp1) {
13385 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13386 }
13387 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13388 {
13389 if (!wxPyCheckForApp()) SWIG_fail;
13390 PyThreadState* __tstate = wxPyBeginAllowThreads();
13391 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13392 wxPyEndAllowThreads(__tstate);
13393 if (PyErr_Occurred()) SWIG_fail;
13394 }
13395 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13396 return resultobj;
13397 fail:
13398 return NULL;
13399 }
13400
13401
13402 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13403 PyObject *resultobj = 0;
13404 int arg1 ;
13405 int arg2 ;
13406 buffer arg3 ;
13407 int arg4 ;
13408 wxImage *result = 0 ;
13409 int val1 ;
13410 int ecode1 = 0 ;
13411 int val2 ;
13412 int ecode2 = 0 ;
13413 PyObject * obj0 = 0 ;
13414 PyObject * obj1 = 0 ;
13415 PyObject * obj2 = 0 ;
13416 char * kwnames[] = {
13417 (char *) "width",(char *) "height",(char *) "data", NULL
13418 };
13419
13420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13421 ecode1 = SWIG_AsVal_int(obj0, &val1);
13422 if (!SWIG_IsOK(ecode1)) {
13423 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13424 }
13425 arg1 = static_cast< int >(val1);
13426 ecode2 = SWIG_AsVal_int(obj1, &val2);
13427 if (!SWIG_IsOK(ecode2)) {
13428 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13429 }
13430 arg2 = static_cast< int >(val2);
13431 {
13432 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &arg4) == -1) SWIG_fail;
13433 }
13434 {
13435 PyThreadState* __tstate = wxPyBeginAllowThreads();
13436 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13437 wxPyEndAllowThreads(__tstate);
13438 if (PyErr_Occurred()) SWIG_fail;
13439 }
13440 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13441 return resultobj;
13442 fail:
13443 return NULL;
13444 }
13445
13446
13447 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13448 PyObject *resultobj = 0;
13449 int arg1 ;
13450 int arg2 ;
13451 buffer arg3 ;
13452 int arg4 ;
13453 buffer arg5 ;
13454 int arg6 ;
13455 wxImage *result = 0 ;
13456 int val1 ;
13457 int ecode1 = 0 ;
13458 int val2 ;
13459 int ecode2 = 0 ;
13460 PyObject * obj0 = 0 ;
13461 PyObject * obj1 = 0 ;
13462 PyObject * obj2 = 0 ;
13463 PyObject * obj3 = 0 ;
13464 char * kwnames[] = {
13465 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13466 };
13467
13468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13469 ecode1 = SWIG_AsVal_int(obj0, &val1);
13470 if (!SWIG_IsOK(ecode1)) {
13471 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13472 }
13473 arg1 = static_cast< int >(val1);
13474 ecode2 = SWIG_AsVal_int(obj1, &val2);
13475 if (!SWIG_IsOK(ecode2)) {
13476 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13477 }
13478 arg2 = static_cast< int >(val2);
13479 {
13480 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &arg4) == -1) SWIG_fail;
13481 }
13482 {
13483 if (obj3 != Py_None) {
13484 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &arg6) == -1) SWIG_fail;
13485 }
13486 }
13487 {
13488 PyThreadState* __tstate = wxPyBeginAllowThreads();
13489 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13490 wxPyEndAllowThreads(__tstate);
13491 if (PyErr_Occurred()) SWIG_fail;
13492 }
13493 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13494 return resultobj;
13495 fail:
13496 return NULL;
13497 }
13498
13499
13500 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13501 PyObject *resultobj = 0;
13502 wxImage *arg1 = (wxImage *) 0 ;
13503 int arg2 ;
13504 int arg3 ;
13505 bool arg4 = (bool) true ;
13506 void *argp1 = 0 ;
13507 int res1 = 0 ;
13508 int val2 ;
13509 int ecode2 = 0 ;
13510 int val3 ;
13511 int ecode3 = 0 ;
13512 bool val4 ;
13513 int ecode4 = 0 ;
13514 PyObject * obj0 = 0 ;
13515 PyObject * obj1 = 0 ;
13516 PyObject * obj2 = 0 ;
13517 PyObject * obj3 = 0 ;
13518 char * kwnames[] = {
13519 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13520 };
13521
13522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13524 if (!SWIG_IsOK(res1)) {
13525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13526 }
13527 arg1 = reinterpret_cast< wxImage * >(argp1);
13528 ecode2 = SWIG_AsVal_int(obj1, &val2);
13529 if (!SWIG_IsOK(ecode2)) {
13530 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13531 }
13532 arg2 = static_cast< int >(val2);
13533 ecode3 = SWIG_AsVal_int(obj2, &val3);
13534 if (!SWIG_IsOK(ecode3)) {
13535 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13536 }
13537 arg3 = static_cast< int >(val3);
13538 if (obj3) {
13539 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13540 if (!SWIG_IsOK(ecode4)) {
13541 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13542 }
13543 arg4 = static_cast< bool >(val4);
13544 }
13545 {
13546 PyThreadState* __tstate = wxPyBeginAllowThreads();
13547 (arg1)->Create(arg2,arg3,arg4);
13548 wxPyEndAllowThreads(__tstate);
13549 if (PyErr_Occurred()) SWIG_fail;
13550 }
13551 resultobj = SWIG_Py_Void();
13552 return resultobj;
13553 fail:
13554 return NULL;
13555 }
13556
13557
13558 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13559 PyObject *resultobj = 0;
13560 wxImage *arg1 = (wxImage *) 0 ;
13561 void *argp1 = 0 ;
13562 int res1 = 0 ;
13563 PyObject *swig_obj[1] ;
13564
13565 if (!args) SWIG_fail;
13566 swig_obj[0] = args;
13567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13568 if (!SWIG_IsOK(res1)) {
13569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13570 }
13571 arg1 = reinterpret_cast< wxImage * >(argp1);
13572 {
13573 PyThreadState* __tstate = wxPyBeginAllowThreads();
13574 (arg1)->Destroy();
13575 wxPyEndAllowThreads(__tstate);
13576 if (PyErr_Occurred()) SWIG_fail;
13577 }
13578 resultobj = SWIG_Py_Void();
13579 return resultobj;
13580 fail:
13581 return NULL;
13582 }
13583
13584
13585 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13586 PyObject *resultobj = 0;
13587 wxImage *arg1 = (wxImage *) 0 ;
13588 int arg2 ;
13589 int arg3 ;
13590 SwigValueWrapper<wxImage > result;
13591 void *argp1 = 0 ;
13592 int res1 = 0 ;
13593 int val2 ;
13594 int ecode2 = 0 ;
13595 int val3 ;
13596 int ecode3 = 0 ;
13597 PyObject * obj0 = 0 ;
13598 PyObject * obj1 = 0 ;
13599 PyObject * obj2 = 0 ;
13600 char * kwnames[] = {
13601 (char *) "self",(char *) "width",(char *) "height", NULL
13602 };
13603
13604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13606 if (!SWIG_IsOK(res1)) {
13607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13608 }
13609 arg1 = reinterpret_cast< wxImage * >(argp1);
13610 ecode2 = SWIG_AsVal_int(obj1, &val2);
13611 if (!SWIG_IsOK(ecode2)) {
13612 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13613 }
13614 arg2 = static_cast< int >(val2);
13615 ecode3 = SWIG_AsVal_int(obj2, &val3);
13616 if (!SWIG_IsOK(ecode3)) {
13617 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13618 }
13619 arg3 = static_cast< int >(val3);
13620 {
13621 PyThreadState* __tstate = wxPyBeginAllowThreads();
13622 result = (arg1)->Scale(arg2,arg3);
13623 wxPyEndAllowThreads(__tstate);
13624 if (PyErr_Occurred()) SWIG_fail;
13625 }
13626 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13627 return resultobj;
13628 fail:
13629 return NULL;
13630 }
13631
13632
13633 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13634 PyObject *resultobj = 0;
13635 wxImage *arg1 = (wxImage *) 0 ;
13636 int arg2 ;
13637 int arg3 ;
13638 SwigValueWrapper<wxImage > result;
13639 void *argp1 = 0 ;
13640 int res1 = 0 ;
13641 int val2 ;
13642 int ecode2 = 0 ;
13643 int val3 ;
13644 int ecode3 = 0 ;
13645 PyObject * obj0 = 0 ;
13646 PyObject * obj1 = 0 ;
13647 PyObject * obj2 = 0 ;
13648 char * kwnames[] = {
13649 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
13650 };
13651
13652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13654 if (!SWIG_IsOK(res1)) {
13655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
13656 }
13657 arg1 = reinterpret_cast< wxImage * >(argp1);
13658 ecode2 = SWIG_AsVal_int(obj1, &val2);
13659 if (!SWIG_IsOK(ecode2)) {
13660 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
13661 }
13662 arg2 = static_cast< int >(val2);
13663 ecode3 = SWIG_AsVal_int(obj2, &val3);
13664 if (!SWIG_IsOK(ecode3)) {
13665 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
13666 }
13667 arg3 = static_cast< int >(val3);
13668 {
13669 PyThreadState* __tstate = wxPyBeginAllowThreads();
13670 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
13671 wxPyEndAllowThreads(__tstate);
13672 if (PyErr_Occurred()) SWIG_fail;
13673 }
13674 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13675 return resultobj;
13676 fail:
13677 return NULL;
13678 }
13679
13680
13681 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13682 PyObject *resultobj = 0;
13683 wxImage *arg1 = (wxImage *) 0 ;
13684 int arg2 ;
13685 int arg3 ;
13686 wxImage *result = 0 ;
13687 void *argp1 = 0 ;
13688 int res1 = 0 ;
13689 int val2 ;
13690 int ecode2 = 0 ;
13691 int val3 ;
13692 int ecode3 = 0 ;
13693 PyObject * obj0 = 0 ;
13694 PyObject * obj1 = 0 ;
13695 PyObject * obj2 = 0 ;
13696 char * kwnames[] = {
13697 (char *) "self",(char *) "width",(char *) "height", NULL
13698 };
13699
13700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13702 if (!SWIG_IsOK(res1)) {
13703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
13704 }
13705 arg1 = reinterpret_cast< wxImage * >(argp1);
13706 ecode2 = SWIG_AsVal_int(obj1, &val2);
13707 if (!SWIG_IsOK(ecode2)) {
13708 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
13709 }
13710 arg2 = static_cast< int >(val2);
13711 ecode3 = SWIG_AsVal_int(obj2, &val3);
13712 if (!SWIG_IsOK(ecode3)) {
13713 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
13714 }
13715 arg3 = static_cast< int >(val3);
13716 {
13717 PyThreadState* __tstate = wxPyBeginAllowThreads();
13718 {
13719 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
13720 result = (wxImage *) &_result_ref;
13721 }
13722 wxPyEndAllowThreads(__tstate);
13723 if (PyErr_Occurred()) SWIG_fail;
13724 }
13725 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13726 return resultobj;
13727 fail:
13728 return NULL;
13729 }
13730
13731
13732 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13733 PyObject *resultobj = 0;
13734 wxImage *arg1 = (wxImage *) 0 ;
13735 wxSize *arg2 = 0 ;
13736 wxPoint *arg3 = 0 ;
13737 int arg4 = (int) -1 ;
13738 int arg5 = (int) -1 ;
13739 int arg6 = (int) -1 ;
13740 wxImage *result = 0 ;
13741 void *argp1 = 0 ;
13742 int res1 = 0 ;
13743 wxSize temp2 ;
13744 wxPoint temp3 ;
13745 int val4 ;
13746 int ecode4 = 0 ;
13747 int val5 ;
13748 int ecode5 = 0 ;
13749 int val6 ;
13750 int ecode6 = 0 ;
13751 PyObject * obj0 = 0 ;
13752 PyObject * obj1 = 0 ;
13753 PyObject * obj2 = 0 ;
13754 PyObject * obj3 = 0 ;
13755 PyObject * obj4 = 0 ;
13756 PyObject * obj5 = 0 ;
13757 char * kwnames[] = {
13758 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13759 };
13760
13761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13763 if (!SWIG_IsOK(res1)) {
13764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
13765 }
13766 arg1 = reinterpret_cast< wxImage * >(argp1);
13767 {
13768 arg2 = &temp2;
13769 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13770 }
13771 {
13772 arg3 = &temp3;
13773 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13774 }
13775 if (obj3) {
13776 ecode4 = SWIG_AsVal_int(obj3, &val4);
13777 if (!SWIG_IsOK(ecode4)) {
13778 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
13779 }
13780 arg4 = static_cast< int >(val4);
13781 }
13782 if (obj4) {
13783 ecode5 = SWIG_AsVal_int(obj4, &val5);
13784 if (!SWIG_IsOK(ecode5)) {
13785 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
13786 }
13787 arg5 = static_cast< int >(val5);
13788 }
13789 if (obj5) {
13790 ecode6 = SWIG_AsVal_int(obj5, &val6);
13791 if (!SWIG_IsOK(ecode6)) {
13792 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
13793 }
13794 arg6 = static_cast< int >(val6);
13795 }
13796 {
13797 PyThreadState* __tstate = wxPyBeginAllowThreads();
13798 {
13799 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13800 result = (wxImage *) &_result_ref;
13801 }
13802 wxPyEndAllowThreads(__tstate);
13803 if (PyErr_Occurred()) SWIG_fail;
13804 }
13805 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13806 return resultobj;
13807 fail:
13808 return NULL;
13809 }
13810
13811
13812 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13813 PyObject *resultobj = 0;
13814 wxImage *arg1 = (wxImage *) 0 ;
13815 int arg2 ;
13816 int arg3 ;
13817 byte arg4 ;
13818 byte arg5 ;
13819 byte arg6 ;
13820 void *argp1 = 0 ;
13821 int res1 = 0 ;
13822 int val2 ;
13823 int ecode2 = 0 ;
13824 int val3 ;
13825 int ecode3 = 0 ;
13826 unsigned char val4 ;
13827 int ecode4 = 0 ;
13828 unsigned char val5 ;
13829 int ecode5 = 0 ;
13830 unsigned char val6 ;
13831 int ecode6 = 0 ;
13832 PyObject * obj0 = 0 ;
13833 PyObject * obj1 = 0 ;
13834 PyObject * obj2 = 0 ;
13835 PyObject * obj3 = 0 ;
13836 PyObject * obj4 = 0 ;
13837 PyObject * obj5 = 0 ;
13838 char * kwnames[] = {
13839 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
13840 };
13841
13842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13844 if (!SWIG_IsOK(res1)) {
13845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
13846 }
13847 arg1 = reinterpret_cast< wxImage * >(argp1);
13848 ecode2 = SWIG_AsVal_int(obj1, &val2);
13849 if (!SWIG_IsOK(ecode2)) {
13850 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
13851 }
13852 arg2 = static_cast< int >(val2);
13853 ecode3 = SWIG_AsVal_int(obj2, &val3);
13854 if (!SWIG_IsOK(ecode3)) {
13855 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
13856 }
13857 arg3 = static_cast< int >(val3);
13858 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13859 if (!SWIG_IsOK(ecode4)) {
13860 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
13861 }
13862 arg4 = static_cast< byte >(val4);
13863 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13864 if (!SWIG_IsOK(ecode5)) {
13865 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
13866 }
13867 arg5 = static_cast< byte >(val5);
13868 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
13869 if (!SWIG_IsOK(ecode6)) {
13870 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
13871 }
13872 arg6 = static_cast< byte >(val6);
13873 {
13874 PyThreadState* __tstate = wxPyBeginAllowThreads();
13875 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
13876 wxPyEndAllowThreads(__tstate);
13877 if (PyErr_Occurred()) SWIG_fail;
13878 }
13879 resultobj = SWIG_Py_Void();
13880 return resultobj;
13881 fail:
13882 return NULL;
13883 }
13884
13885
13886 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13887 PyObject *resultobj = 0;
13888 wxImage *arg1 = (wxImage *) 0 ;
13889 wxRect *arg2 = 0 ;
13890 byte arg3 ;
13891 byte arg4 ;
13892 byte arg5 ;
13893 void *argp1 = 0 ;
13894 int res1 = 0 ;
13895 wxRect temp2 ;
13896 unsigned char val3 ;
13897 int ecode3 = 0 ;
13898 unsigned char val4 ;
13899 int ecode4 = 0 ;
13900 unsigned char val5 ;
13901 int ecode5 = 0 ;
13902 PyObject * obj0 = 0 ;
13903 PyObject * obj1 = 0 ;
13904 PyObject * obj2 = 0 ;
13905 PyObject * obj3 = 0 ;
13906 PyObject * obj4 = 0 ;
13907 char * kwnames[] = {
13908 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
13909 };
13910
13911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13913 if (!SWIG_IsOK(res1)) {
13914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
13915 }
13916 arg1 = reinterpret_cast< wxImage * >(argp1);
13917 {
13918 arg2 = &temp2;
13919 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13920 }
13921 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
13922 if (!SWIG_IsOK(ecode3)) {
13923 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
13924 }
13925 arg3 = static_cast< byte >(val3);
13926 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13927 if (!SWIG_IsOK(ecode4)) {
13928 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
13929 }
13930 arg4 = static_cast< byte >(val4);
13931 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13932 if (!SWIG_IsOK(ecode5)) {
13933 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
13934 }
13935 arg5 = static_cast< byte >(val5);
13936 {
13937 PyThreadState* __tstate = wxPyBeginAllowThreads();
13938 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
13939 wxPyEndAllowThreads(__tstate);
13940 if (PyErr_Occurred()) SWIG_fail;
13941 }
13942 resultobj = SWIG_Py_Void();
13943 return resultobj;
13944 fail:
13945 return NULL;
13946 }
13947
13948
13949 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13950 PyObject *resultobj = 0;
13951 wxImage *arg1 = (wxImage *) 0 ;
13952 int arg2 ;
13953 int arg3 ;
13954 byte result;
13955 void *argp1 = 0 ;
13956 int res1 = 0 ;
13957 int val2 ;
13958 int ecode2 = 0 ;
13959 int val3 ;
13960 int ecode3 = 0 ;
13961 PyObject * obj0 = 0 ;
13962 PyObject * obj1 = 0 ;
13963 PyObject * obj2 = 0 ;
13964 char * kwnames[] = {
13965 (char *) "self",(char *) "x",(char *) "y", NULL
13966 };
13967
13968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13970 if (!SWIG_IsOK(res1)) {
13971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
13972 }
13973 arg1 = reinterpret_cast< wxImage * >(argp1);
13974 ecode2 = SWIG_AsVal_int(obj1, &val2);
13975 if (!SWIG_IsOK(ecode2)) {
13976 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
13977 }
13978 arg2 = static_cast< int >(val2);
13979 ecode3 = SWIG_AsVal_int(obj2, &val3);
13980 if (!SWIG_IsOK(ecode3)) {
13981 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
13982 }
13983 arg3 = static_cast< int >(val3);
13984 {
13985 PyThreadState* __tstate = wxPyBeginAllowThreads();
13986 result = (byte)(arg1)->GetRed(arg2,arg3);
13987 wxPyEndAllowThreads(__tstate);
13988 if (PyErr_Occurred()) SWIG_fail;
13989 }
13990 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13991 return resultobj;
13992 fail:
13993 return NULL;
13994 }
13995
13996
13997 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13998 PyObject *resultobj = 0;
13999 wxImage *arg1 = (wxImage *) 0 ;
14000 int arg2 ;
14001 int arg3 ;
14002 byte result;
14003 void *argp1 = 0 ;
14004 int res1 = 0 ;
14005 int val2 ;
14006 int ecode2 = 0 ;
14007 int val3 ;
14008 int ecode3 = 0 ;
14009 PyObject * obj0 = 0 ;
14010 PyObject * obj1 = 0 ;
14011 PyObject * obj2 = 0 ;
14012 char * kwnames[] = {
14013 (char *) "self",(char *) "x",(char *) "y", NULL
14014 };
14015
14016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14018 if (!SWIG_IsOK(res1)) {
14019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
14020 }
14021 arg1 = reinterpret_cast< wxImage * >(argp1);
14022 ecode2 = SWIG_AsVal_int(obj1, &val2);
14023 if (!SWIG_IsOK(ecode2)) {
14024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
14025 }
14026 arg2 = static_cast< int >(val2);
14027 ecode3 = SWIG_AsVal_int(obj2, &val3);
14028 if (!SWIG_IsOK(ecode3)) {
14029 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
14030 }
14031 arg3 = static_cast< int >(val3);
14032 {
14033 PyThreadState* __tstate = wxPyBeginAllowThreads();
14034 result = (byte)(arg1)->GetGreen(arg2,arg3);
14035 wxPyEndAllowThreads(__tstate);
14036 if (PyErr_Occurred()) SWIG_fail;
14037 }
14038 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14039 return resultobj;
14040 fail:
14041 return NULL;
14042 }
14043
14044
14045 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14046 PyObject *resultobj = 0;
14047 wxImage *arg1 = (wxImage *) 0 ;
14048 int arg2 ;
14049 int arg3 ;
14050 byte result;
14051 void *argp1 = 0 ;
14052 int res1 = 0 ;
14053 int val2 ;
14054 int ecode2 = 0 ;
14055 int val3 ;
14056 int ecode3 = 0 ;
14057 PyObject * obj0 = 0 ;
14058 PyObject * obj1 = 0 ;
14059 PyObject * obj2 = 0 ;
14060 char * kwnames[] = {
14061 (char *) "self",(char *) "x",(char *) "y", NULL
14062 };
14063
14064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14066 if (!SWIG_IsOK(res1)) {
14067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
14068 }
14069 arg1 = reinterpret_cast< wxImage * >(argp1);
14070 ecode2 = SWIG_AsVal_int(obj1, &val2);
14071 if (!SWIG_IsOK(ecode2)) {
14072 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
14073 }
14074 arg2 = static_cast< int >(val2);
14075 ecode3 = SWIG_AsVal_int(obj2, &val3);
14076 if (!SWIG_IsOK(ecode3)) {
14077 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
14078 }
14079 arg3 = static_cast< int >(val3);
14080 {
14081 PyThreadState* __tstate = wxPyBeginAllowThreads();
14082 result = (byte)(arg1)->GetBlue(arg2,arg3);
14083 wxPyEndAllowThreads(__tstate);
14084 if (PyErr_Occurred()) SWIG_fail;
14085 }
14086 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14087 return resultobj;
14088 fail:
14089 return NULL;
14090 }
14091
14092
14093 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14094 PyObject *resultobj = 0;
14095 wxImage *arg1 = (wxImage *) 0 ;
14096 int arg2 ;
14097 int arg3 ;
14098 byte arg4 ;
14099 void *argp1 = 0 ;
14100 int res1 = 0 ;
14101 int val2 ;
14102 int ecode2 = 0 ;
14103 int val3 ;
14104 int ecode3 = 0 ;
14105 unsigned char val4 ;
14106 int ecode4 = 0 ;
14107 PyObject * obj0 = 0 ;
14108 PyObject * obj1 = 0 ;
14109 PyObject * obj2 = 0 ;
14110 PyObject * obj3 = 0 ;
14111 char * kwnames[] = {
14112 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
14113 };
14114
14115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14117 if (!SWIG_IsOK(res1)) {
14118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14119 }
14120 arg1 = reinterpret_cast< wxImage * >(argp1);
14121 ecode2 = SWIG_AsVal_int(obj1, &val2);
14122 if (!SWIG_IsOK(ecode2)) {
14123 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
14124 }
14125 arg2 = static_cast< int >(val2);
14126 ecode3 = SWIG_AsVal_int(obj2, &val3);
14127 if (!SWIG_IsOK(ecode3)) {
14128 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
14129 }
14130 arg3 = static_cast< int >(val3);
14131 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14132 if (!SWIG_IsOK(ecode4)) {
14133 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
14134 }
14135 arg4 = static_cast< byte >(val4);
14136 {
14137 PyThreadState* __tstate = wxPyBeginAllowThreads();
14138 (arg1)->SetAlpha(arg2,arg3,arg4);
14139 wxPyEndAllowThreads(__tstate);
14140 if (PyErr_Occurred()) SWIG_fail;
14141 }
14142 resultobj = SWIG_Py_Void();
14143 return resultobj;
14144 fail:
14145 return NULL;
14146 }
14147
14148
14149 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14150 PyObject *resultobj = 0;
14151 wxImage *arg1 = (wxImage *) 0 ;
14152 int arg2 ;
14153 int arg3 ;
14154 byte result;
14155 void *argp1 = 0 ;
14156 int res1 = 0 ;
14157 int val2 ;
14158 int ecode2 = 0 ;
14159 int val3 ;
14160 int ecode3 = 0 ;
14161 PyObject * obj0 = 0 ;
14162 PyObject * obj1 = 0 ;
14163 PyObject * obj2 = 0 ;
14164 char * kwnames[] = {
14165 (char *) "self",(char *) "x",(char *) "y", NULL
14166 };
14167
14168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14170 if (!SWIG_IsOK(res1)) {
14171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14172 }
14173 arg1 = reinterpret_cast< wxImage * >(argp1);
14174 ecode2 = SWIG_AsVal_int(obj1, &val2);
14175 if (!SWIG_IsOK(ecode2)) {
14176 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
14177 }
14178 arg2 = static_cast< int >(val2);
14179 ecode3 = SWIG_AsVal_int(obj2, &val3);
14180 if (!SWIG_IsOK(ecode3)) {
14181 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
14182 }
14183 arg3 = static_cast< int >(val3);
14184 {
14185 PyThreadState* __tstate = wxPyBeginAllowThreads();
14186 result = (byte)(arg1)->GetAlpha(arg2,arg3);
14187 wxPyEndAllowThreads(__tstate);
14188 if (PyErr_Occurred()) SWIG_fail;
14189 }
14190 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14191 return resultobj;
14192 fail:
14193 return NULL;
14194 }
14195
14196
14197 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14198 PyObject *resultobj = 0;
14199 wxImage *arg1 = (wxImage *) 0 ;
14200 bool result;
14201 void *argp1 = 0 ;
14202 int res1 = 0 ;
14203 PyObject *swig_obj[1] ;
14204
14205 if (!args) SWIG_fail;
14206 swig_obj[0] = args;
14207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14208 if (!SWIG_IsOK(res1)) {
14209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14210 }
14211 arg1 = reinterpret_cast< wxImage * >(argp1);
14212 {
14213 PyThreadState* __tstate = wxPyBeginAllowThreads();
14214 result = (bool)(arg1)->HasAlpha();
14215 wxPyEndAllowThreads(__tstate);
14216 if (PyErr_Occurred()) SWIG_fail;
14217 }
14218 {
14219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14220 }
14221 return resultobj;
14222 fail:
14223 return NULL;
14224 }
14225
14226
14227 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14228 PyObject *resultobj = 0;
14229 wxImage *arg1 = (wxImage *) 0 ;
14230 void *argp1 = 0 ;
14231 int res1 = 0 ;
14232 PyObject *swig_obj[1] ;
14233
14234 if (!args) SWIG_fail;
14235 swig_obj[0] = args;
14236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14237 if (!SWIG_IsOK(res1)) {
14238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14239 }
14240 arg1 = reinterpret_cast< wxImage * >(argp1);
14241 {
14242 PyThreadState* __tstate = wxPyBeginAllowThreads();
14243 (arg1)->InitAlpha();
14244 wxPyEndAllowThreads(__tstate);
14245 if (PyErr_Occurred()) SWIG_fail;
14246 }
14247 resultobj = SWIG_Py_Void();
14248 return resultobj;
14249 fail:
14250 return NULL;
14251 }
14252
14253
14254 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14255 PyObject *resultobj = 0;
14256 wxImage *arg1 = (wxImage *) 0 ;
14257 int arg2 ;
14258 int arg3 ;
14259 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14260 bool result;
14261 void *argp1 = 0 ;
14262 int res1 = 0 ;
14263 int val2 ;
14264 int ecode2 = 0 ;
14265 int val3 ;
14266 int ecode3 = 0 ;
14267 unsigned char val4 ;
14268 int ecode4 = 0 ;
14269 PyObject * obj0 = 0 ;
14270 PyObject * obj1 = 0 ;
14271 PyObject * obj2 = 0 ;
14272 PyObject * obj3 = 0 ;
14273 char * kwnames[] = {
14274 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14275 };
14276
14277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14279 if (!SWIG_IsOK(res1)) {
14280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14281 }
14282 arg1 = reinterpret_cast< wxImage * >(argp1);
14283 ecode2 = SWIG_AsVal_int(obj1, &val2);
14284 if (!SWIG_IsOK(ecode2)) {
14285 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14286 }
14287 arg2 = static_cast< int >(val2);
14288 ecode3 = SWIG_AsVal_int(obj2, &val3);
14289 if (!SWIG_IsOK(ecode3)) {
14290 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14291 }
14292 arg3 = static_cast< int >(val3);
14293 if (obj3) {
14294 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14295 if (!SWIG_IsOK(ecode4)) {
14296 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14297 }
14298 arg4 = static_cast< byte >(val4);
14299 }
14300 {
14301 PyThreadState* __tstate = wxPyBeginAllowThreads();
14302 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14303 wxPyEndAllowThreads(__tstate);
14304 if (PyErr_Occurred()) SWIG_fail;
14305 }
14306 {
14307 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14308 }
14309 return resultobj;
14310 fail:
14311 return NULL;
14312 }
14313
14314
14315 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14316 PyObject *resultobj = 0;
14317 wxImage *arg1 = (wxImage *) 0 ;
14318 byte *arg2 = (byte *) 0 ;
14319 byte *arg3 = (byte *) 0 ;
14320 byte *arg4 = (byte *) 0 ;
14321 byte arg5 = (byte) 0 ;
14322 byte arg6 = (byte) 0 ;
14323 byte arg7 = (byte) 0 ;
14324 bool result;
14325 void *argp1 = 0 ;
14326 int res1 = 0 ;
14327 byte temp2 ;
14328 int res2 = SWIG_TMPOBJ ;
14329 byte temp3 ;
14330 int res3 = SWIG_TMPOBJ ;
14331 byte temp4 ;
14332 int res4 = SWIG_TMPOBJ ;
14333 unsigned char val5 ;
14334 int ecode5 = 0 ;
14335 unsigned char val6 ;
14336 int ecode6 = 0 ;
14337 unsigned char val7 ;
14338 int ecode7 = 0 ;
14339 PyObject * obj0 = 0 ;
14340 PyObject * obj1 = 0 ;
14341 PyObject * obj2 = 0 ;
14342 PyObject * obj3 = 0 ;
14343 char * kwnames[] = {
14344 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14345 };
14346
14347 arg2 = &temp2;
14348 arg3 = &temp3;
14349 arg4 = &temp4;
14350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14352 if (!SWIG_IsOK(res1)) {
14353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14354 }
14355 arg1 = reinterpret_cast< wxImage * >(argp1);
14356 if (obj1) {
14357 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14358 if (!SWIG_IsOK(ecode5)) {
14359 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14360 }
14361 arg5 = static_cast< byte >(val5);
14362 }
14363 if (obj2) {
14364 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14365 if (!SWIG_IsOK(ecode6)) {
14366 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14367 }
14368 arg6 = static_cast< byte >(val6);
14369 }
14370 if (obj3) {
14371 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14372 if (!SWIG_IsOK(ecode7)) {
14373 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14374 }
14375 arg7 = static_cast< byte >(val7);
14376 }
14377 {
14378 PyThreadState* __tstate = wxPyBeginAllowThreads();
14379 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14380 wxPyEndAllowThreads(__tstate);
14381 if (PyErr_Occurred()) SWIG_fail;
14382 }
14383 {
14384 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14385 }
14386 if (SWIG_IsTmpObj(res2)) {
14387 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14388 } else {
14389 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14390 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14391 }
14392 if (SWIG_IsTmpObj(res3)) {
14393 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14394 } else {
14395 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14396 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14397 }
14398 if (SWIG_IsTmpObj(res4)) {
14399 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14400 } else {
14401 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14402 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14403 }
14404 return resultobj;
14405 fail:
14406 return NULL;
14407 }
14408
14409
14410 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14411 PyObject *resultobj = 0;
14412 wxImage *arg1 = (wxImage *) 0 ;
14413 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14414 bool result;
14415 void *argp1 = 0 ;
14416 int res1 = 0 ;
14417 unsigned char val2 ;
14418 int ecode2 = 0 ;
14419 PyObject * obj0 = 0 ;
14420 PyObject * obj1 = 0 ;
14421 char * kwnames[] = {
14422 (char *) "self",(char *) "threshold", NULL
14423 };
14424
14425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14427 if (!SWIG_IsOK(res1)) {
14428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14429 }
14430 arg1 = reinterpret_cast< wxImage * >(argp1);
14431 if (obj1) {
14432 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14433 if (!SWIG_IsOK(ecode2)) {
14434 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14435 }
14436 arg2 = static_cast< byte >(val2);
14437 }
14438 {
14439 PyThreadState* __tstate = wxPyBeginAllowThreads();
14440 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14441 wxPyEndAllowThreads(__tstate);
14442 if (PyErr_Occurred()) SWIG_fail;
14443 }
14444 {
14445 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14446 }
14447 return resultobj;
14448 fail:
14449 return NULL;
14450 }
14451
14452
14453 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14454 PyObject *resultobj = 0;
14455 wxImage *arg1 = (wxImage *) 0 ;
14456 byte arg2 ;
14457 byte arg3 ;
14458 byte arg4 ;
14459 bool result;
14460 void *argp1 = 0 ;
14461 int res1 = 0 ;
14462 unsigned char val2 ;
14463 int ecode2 = 0 ;
14464 unsigned char val3 ;
14465 int ecode3 = 0 ;
14466 unsigned char val4 ;
14467 int ecode4 = 0 ;
14468 PyObject * obj0 = 0 ;
14469 PyObject * obj1 = 0 ;
14470 PyObject * obj2 = 0 ;
14471 PyObject * obj3 = 0 ;
14472 char * kwnames[] = {
14473 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14474 };
14475
14476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14478 if (!SWIG_IsOK(res1)) {
14479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14480 }
14481 arg1 = reinterpret_cast< wxImage * >(argp1);
14482 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14483 if (!SWIG_IsOK(ecode2)) {
14484 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14485 }
14486 arg2 = static_cast< byte >(val2);
14487 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14488 if (!SWIG_IsOK(ecode3)) {
14489 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
14490 }
14491 arg3 = static_cast< byte >(val3);
14492 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14493 if (!SWIG_IsOK(ecode4)) {
14494 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
14495 }
14496 arg4 = static_cast< byte >(val4);
14497 {
14498 PyThreadState* __tstate = wxPyBeginAllowThreads();
14499 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
14500 wxPyEndAllowThreads(__tstate);
14501 if (PyErr_Occurred()) SWIG_fail;
14502 }
14503 {
14504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14505 }
14506 return resultobj;
14507 fail:
14508 return NULL;
14509 }
14510
14511
14512 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14513 PyObject *resultobj = 0;
14514 wxImage *arg1 = (wxImage *) 0 ;
14515 wxImage *arg2 = 0 ;
14516 byte arg3 ;
14517 byte arg4 ;
14518 byte arg5 ;
14519 bool result;
14520 void *argp1 = 0 ;
14521 int res1 = 0 ;
14522 void *argp2 = 0 ;
14523 int res2 = 0 ;
14524 unsigned char val3 ;
14525 int ecode3 = 0 ;
14526 unsigned char val4 ;
14527 int ecode4 = 0 ;
14528 unsigned char val5 ;
14529 int ecode5 = 0 ;
14530 PyObject * obj0 = 0 ;
14531 PyObject * obj1 = 0 ;
14532 PyObject * obj2 = 0 ;
14533 PyObject * obj3 = 0 ;
14534 PyObject * obj4 = 0 ;
14535 char * kwnames[] = {
14536 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
14537 };
14538
14539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14541 if (!SWIG_IsOK(res1)) {
14542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
14543 }
14544 arg1 = reinterpret_cast< wxImage * >(argp1);
14545 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
14546 if (!SWIG_IsOK(res2)) {
14547 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14548 }
14549 if (!argp2) {
14550 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14551 }
14552 arg2 = reinterpret_cast< wxImage * >(argp2);
14553 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14554 if (!SWIG_IsOK(ecode3)) {
14555 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
14556 }
14557 arg3 = static_cast< byte >(val3);
14558 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14559 if (!SWIG_IsOK(ecode4)) {
14560 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
14561 }
14562 arg4 = static_cast< byte >(val4);
14563 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14564 if (!SWIG_IsOK(ecode5)) {
14565 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
14566 }
14567 arg5 = static_cast< byte >(val5);
14568 {
14569 PyThreadState* __tstate = wxPyBeginAllowThreads();
14570 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
14571 wxPyEndAllowThreads(__tstate);
14572 if (PyErr_Occurred()) SWIG_fail;
14573 }
14574 {
14575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14576 }
14577 return resultobj;
14578 fail:
14579 return NULL;
14580 }
14581
14582
14583 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14584 PyObject *resultobj = 0;
14585 wxString *arg1 = 0 ;
14586 bool result;
14587 bool temp1 = false ;
14588 PyObject * obj0 = 0 ;
14589 char * kwnames[] = {
14590 (char *) "filename", NULL
14591 };
14592
14593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
14594 {
14595 arg1 = wxString_in_helper(obj0);
14596 if (arg1 == NULL) SWIG_fail;
14597 temp1 = true;
14598 }
14599 {
14600 PyThreadState* __tstate = wxPyBeginAllowThreads();
14601 result = (bool)wxImage::CanRead((wxString const &)*arg1);
14602 wxPyEndAllowThreads(__tstate);
14603 if (PyErr_Occurred()) SWIG_fail;
14604 }
14605 {
14606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14607 }
14608 {
14609 if (temp1)
14610 delete arg1;
14611 }
14612 return resultobj;
14613 fail:
14614 {
14615 if (temp1)
14616 delete arg1;
14617 }
14618 return NULL;
14619 }
14620
14621
14622 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14623 PyObject *resultobj = 0;
14624 wxString *arg1 = 0 ;
14625 long arg2 = (long) wxBITMAP_TYPE_ANY ;
14626 int result;
14627 bool temp1 = false ;
14628 long val2 ;
14629 int ecode2 = 0 ;
14630 PyObject * obj0 = 0 ;
14631 PyObject * obj1 = 0 ;
14632 char * kwnames[] = {
14633 (char *) "filename",(char *) "type", NULL
14634 };
14635
14636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
14637 {
14638 arg1 = wxString_in_helper(obj0);
14639 if (arg1 == NULL) SWIG_fail;
14640 temp1 = true;
14641 }
14642 if (obj1) {
14643 ecode2 = SWIG_AsVal_long(obj1, &val2);
14644 if (!SWIG_IsOK(ecode2)) {
14645 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
14646 }
14647 arg2 = static_cast< long >(val2);
14648 }
14649 {
14650 PyThreadState* __tstate = wxPyBeginAllowThreads();
14651 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
14652 wxPyEndAllowThreads(__tstate);
14653 if (PyErr_Occurred()) SWIG_fail;
14654 }
14655 resultobj = SWIG_From_int(static_cast< int >(result));
14656 {
14657 if (temp1)
14658 delete arg1;
14659 }
14660 return resultobj;
14661 fail:
14662 {
14663 if (temp1)
14664 delete arg1;
14665 }
14666 return NULL;
14667 }
14668
14669
14670 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14671 PyObject *resultobj = 0;
14672 wxImage *arg1 = (wxImage *) 0 ;
14673 wxString *arg2 = 0 ;
14674 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14675 int arg4 = (int) -1 ;
14676 bool result;
14677 void *argp1 = 0 ;
14678 int res1 = 0 ;
14679 bool temp2 = false ;
14680 long val3 ;
14681 int ecode3 = 0 ;
14682 int val4 ;
14683 int ecode4 = 0 ;
14684 PyObject * obj0 = 0 ;
14685 PyObject * obj1 = 0 ;
14686 PyObject * obj2 = 0 ;
14687 PyObject * obj3 = 0 ;
14688 char * kwnames[] = {
14689 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
14690 };
14691
14692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14694 if (!SWIG_IsOK(res1)) {
14695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
14696 }
14697 arg1 = reinterpret_cast< wxImage * >(argp1);
14698 {
14699 arg2 = wxString_in_helper(obj1);
14700 if (arg2 == NULL) SWIG_fail;
14701 temp2 = true;
14702 }
14703 if (obj2) {
14704 ecode3 = SWIG_AsVal_long(obj2, &val3);
14705 if (!SWIG_IsOK(ecode3)) {
14706 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
14707 }
14708 arg3 = static_cast< long >(val3);
14709 }
14710 if (obj3) {
14711 ecode4 = SWIG_AsVal_int(obj3, &val4);
14712 if (!SWIG_IsOK(ecode4)) {
14713 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
14714 }
14715 arg4 = static_cast< int >(val4);
14716 }
14717 {
14718 PyThreadState* __tstate = wxPyBeginAllowThreads();
14719 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
14720 wxPyEndAllowThreads(__tstate);
14721 if (PyErr_Occurred()) SWIG_fail;
14722 }
14723 {
14724 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14725 }
14726 {
14727 if (temp2)
14728 delete arg2;
14729 }
14730 return resultobj;
14731 fail:
14732 {
14733 if (temp2)
14734 delete arg2;
14735 }
14736 return NULL;
14737 }
14738
14739
14740 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14741 PyObject *resultobj = 0;
14742 wxImage *arg1 = (wxImage *) 0 ;
14743 wxString *arg2 = 0 ;
14744 wxString *arg3 = 0 ;
14745 int arg4 = (int) -1 ;
14746 bool result;
14747 void *argp1 = 0 ;
14748 int res1 = 0 ;
14749 bool temp2 = false ;
14750 bool temp3 = false ;
14751 int val4 ;
14752 int ecode4 = 0 ;
14753 PyObject * obj0 = 0 ;
14754 PyObject * obj1 = 0 ;
14755 PyObject * obj2 = 0 ;
14756 PyObject * obj3 = 0 ;
14757 char * kwnames[] = {
14758 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
14759 };
14760
14761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14763 if (!SWIG_IsOK(res1)) {
14764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14765 }
14766 arg1 = reinterpret_cast< wxImage * >(argp1);
14767 {
14768 arg2 = wxString_in_helper(obj1);
14769 if (arg2 == NULL) SWIG_fail;
14770 temp2 = true;
14771 }
14772 {
14773 arg3 = wxString_in_helper(obj2);
14774 if (arg3 == NULL) SWIG_fail;
14775 temp3 = true;
14776 }
14777 if (obj3) {
14778 ecode4 = SWIG_AsVal_int(obj3, &val4);
14779 if (!SWIG_IsOK(ecode4)) {
14780 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
14781 }
14782 arg4 = static_cast< int >(val4);
14783 }
14784 {
14785 PyThreadState* __tstate = wxPyBeginAllowThreads();
14786 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14787 wxPyEndAllowThreads(__tstate);
14788 if (PyErr_Occurred()) SWIG_fail;
14789 }
14790 {
14791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14792 }
14793 {
14794 if (temp2)
14795 delete arg2;
14796 }
14797 {
14798 if (temp3)
14799 delete arg3;
14800 }
14801 return resultobj;
14802 fail:
14803 {
14804 if (temp2)
14805 delete arg2;
14806 }
14807 {
14808 if (temp3)
14809 delete arg3;
14810 }
14811 return NULL;
14812 }
14813
14814
14815 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14816 PyObject *resultobj = 0;
14817 wxImage *arg1 = (wxImage *) 0 ;
14818 wxString *arg2 = 0 ;
14819 int arg3 ;
14820 bool result;
14821 void *argp1 = 0 ;
14822 int res1 = 0 ;
14823 bool temp2 = false ;
14824 int val3 ;
14825 int ecode3 = 0 ;
14826 PyObject * obj0 = 0 ;
14827 PyObject * obj1 = 0 ;
14828 PyObject * obj2 = 0 ;
14829 char * kwnames[] = {
14830 (char *) "self",(char *) "name",(char *) "type", NULL
14831 };
14832
14833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14835 if (!SWIG_IsOK(res1)) {
14836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
14837 }
14838 arg1 = reinterpret_cast< wxImage * >(argp1);
14839 {
14840 arg2 = wxString_in_helper(obj1);
14841 if (arg2 == NULL) SWIG_fail;
14842 temp2 = true;
14843 }
14844 ecode3 = SWIG_AsVal_int(obj2, &val3);
14845 if (!SWIG_IsOK(ecode3)) {
14846 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
14847 }
14848 arg3 = static_cast< int >(val3);
14849 {
14850 PyThreadState* __tstate = wxPyBeginAllowThreads();
14851 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
14852 wxPyEndAllowThreads(__tstate);
14853 if (PyErr_Occurred()) SWIG_fail;
14854 }
14855 {
14856 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14857 }
14858 {
14859 if (temp2)
14860 delete arg2;
14861 }
14862 return resultobj;
14863 fail:
14864 {
14865 if (temp2)
14866 delete arg2;
14867 }
14868 return NULL;
14869 }
14870
14871
14872 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14873 PyObject *resultobj = 0;
14874 wxImage *arg1 = (wxImage *) 0 ;
14875 wxString *arg2 = 0 ;
14876 wxString *arg3 = 0 ;
14877 bool result;
14878 void *argp1 = 0 ;
14879 int res1 = 0 ;
14880 bool temp2 = false ;
14881 bool temp3 = false ;
14882 PyObject * obj0 = 0 ;
14883 PyObject * obj1 = 0 ;
14884 PyObject * obj2 = 0 ;
14885 char * kwnames[] = {
14886 (char *) "self",(char *) "name",(char *) "mimetype", NULL
14887 };
14888
14889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14891 if (!SWIG_IsOK(res1)) {
14892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14893 }
14894 arg1 = reinterpret_cast< wxImage * >(argp1);
14895 {
14896 arg2 = wxString_in_helper(obj1);
14897 if (arg2 == NULL) SWIG_fail;
14898 temp2 = true;
14899 }
14900 {
14901 arg3 = wxString_in_helper(obj2);
14902 if (arg3 == NULL) SWIG_fail;
14903 temp3 = true;
14904 }
14905 {
14906 PyThreadState* __tstate = wxPyBeginAllowThreads();
14907 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
14908 wxPyEndAllowThreads(__tstate);
14909 if (PyErr_Occurred()) SWIG_fail;
14910 }
14911 {
14912 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14913 }
14914 {
14915 if (temp2)
14916 delete arg2;
14917 }
14918 {
14919 if (temp3)
14920 delete arg3;
14921 }
14922 return resultobj;
14923 fail:
14924 {
14925 if (temp2)
14926 delete arg2;
14927 }
14928 {
14929 if (temp3)
14930 delete arg3;
14931 }
14932 return NULL;
14933 }
14934
14935
14936 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14937 PyObject *resultobj = 0;
14938 wxInputStream *arg1 = 0 ;
14939 bool result;
14940 wxPyInputStream *temp1 ;
14941 bool created1 ;
14942 PyObject * obj0 = 0 ;
14943 char * kwnames[] = {
14944 (char *) "stream", NULL
14945 };
14946
14947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
14948 {
14949 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
14950 arg1 = temp1->m_wxis;
14951 created1 = false;
14952 } else {
14953 PyErr_Clear(); // clear the failure of the wxPyConvert above
14954 arg1 = wxPyCBInputStream_create(obj0, false);
14955 if (arg1 == NULL) {
14956 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14957 SWIG_fail;
14958 }
14959 created1 = true;
14960 }
14961 }
14962 {
14963 PyThreadState* __tstate = wxPyBeginAllowThreads();
14964 result = (bool)wxImage::CanRead(*arg1);
14965 wxPyEndAllowThreads(__tstate);
14966 if (PyErr_Occurred()) SWIG_fail;
14967 }
14968 {
14969 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14970 }
14971 {
14972 if (created1) delete arg1;
14973 }
14974 return resultobj;
14975 fail:
14976 {
14977 if (created1) delete arg1;
14978 }
14979 return NULL;
14980 }
14981
14982
14983 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14984 PyObject *resultobj = 0;
14985 wxImage *arg1 = (wxImage *) 0 ;
14986 wxInputStream *arg2 = 0 ;
14987 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14988 int arg4 = (int) -1 ;
14989 bool result;
14990 void *argp1 = 0 ;
14991 int res1 = 0 ;
14992 wxPyInputStream *temp2 ;
14993 bool created2 ;
14994 long val3 ;
14995 int ecode3 = 0 ;
14996 int val4 ;
14997 int ecode4 = 0 ;
14998 PyObject * obj0 = 0 ;
14999 PyObject * obj1 = 0 ;
15000 PyObject * obj2 = 0 ;
15001 PyObject * obj3 = 0 ;
15002 char * kwnames[] = {
15003 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
15004 };
15005
15006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15008 if (!SWIG_IsOK(res1)) {
15009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
15010 }
15011 arg1 = reinterpret_cast< wxImage * >(argp1);
15012 {
15013 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15014 arg2 = temp2->m_wxis;
15015 created2 = false;
15016 } else {
15017 PyErr_Clear(); // clear the failure of the wxPyConvert above
15018 arg2 = wxPyCBInputStream_create(obj1, false);
15019 if (arg2 == NULL) {
15020 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15021 SWIG_fail;
15022 }
15023 created2 = true;
15024 }
15025 }
15026 if (obj2) {
15027 ecode3 = SWIG_AsVal_long(obj2, &val3);
15028 if (!SWIG_IsOK(ecode3)) {
15029 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
15030 }
15031 arg3 = static_cast< long >(val3);
15032 }
15033 if (obj3) {
15034 ecode4 = SWIG_AsVal_int(obj3, &val4);
15035 if (!SWIG_IsOK(ecode4)) {
15036 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
15037 }
15038 arg4 = static_cast< int >(val4);
15039 }
15040 {
15041 PyThreadState* __tstate = wxPyBeginAllowThreads();
15042 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
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 (created2) delete arg2;
15051 }
15052 return resultobj;
15053 fail:
15054 {
15055 if (created2) delete arg2;
15056 }
15057 return NULL;
15058 }
15059
15060
15061 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15062 PyObject *resultobj = 0;
15063 wxImage *arg1 = (wxImage *) 0 ;
15064 wxInputStream *arg2 = 0 ;
15065 wxString *arg3 = 0 ;
15066 int arg4 = (int) -1 ;
15067 bool result;
15068 void *argp1 = 0 ;
15069 int res1 = 0 ;
15070 wxPyInputStream *temp2 ;
15071 bool created2 ;
15072 bool temp3 = false ;
15073 int val4 ;
15074 int ecode4 = 0 ;
15075 PyObject * obj0 = 0 ;
15076 PyObject * obj1 = 0 ;
15077 PyObject * obj2 = 0 ;
15078 PyObject * obj3 = 0 ;
15079 char * kwnames[] = {
15080 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
15081 };
15082
15083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15085 if (!SWIG_IsOK(res1)) {
15086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
15087 }
15088 arg1 = reinterpret_cast< wxImage * >(argp1);
15089 {
15090 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15091 arg2 = temp2->m_wxis;
15092 created2 = false;
15093 } else {
15094 PyErr_Clear(); // clear the failure of the wxPyConvert above
15095 arg2 = wxPyCBInputStream_create(obj1, false);
15096 if (arg2 == NULL) {
15097 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15098 SWIG_fail;
15099 }
15100 created2 = true;
15101 }
15102 }
15103 {
15104 arg3 = wxString_in_helper(obj2);
15105 if (arg3 == NULL) SWIG_fail;
15106 temp3 = true;
15107 }
15108 if (obj3) {
15109 ecode4 = SWIG_AsVal_int(obj3, &val4);
15110 if (!SWIG_IsOK(ecode4)) {
15111 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
15112 }
15113 arg4 = static_cast< int >(val4);
15114 }
15115 {
15116 PyThreadState* __tstate = wxPyBeginAllowThreads();
15117 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
15118 wxPyEndAllowThreads(__tstate);
15119 if (PyErr_Occurred()) SWIG_fail;
15120 }
15121 {
15122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15123 }
15124 {
15125 if (created2) delete arg2;
15126 }
15127 {
15128 if (temp3)
15129 delete arg3;
15130 }
15131 return resultobj;
15132 fail:
15133 {
15134 if (created2) delete arg2;
15135 }
15136 {
15137 if (temp3)
15138 delete arg3;
15139 }
15140 return NULL;
15141 }
15142
15143
15144 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15145 PyObject *resultobj = 0;
15146 wxImage *arg1 = (wxImage *) 0 ;
15147 bool result;
15148 void *argp1 = 0 ;
15149 int res1 = 0 ;
15150 PyObject *swig_obj[1] ;
15151
15152 if (!args) SWIG_fail;
15153 swig_obj[0] = args;
15154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15155 if (!SWIG_IsOK(res1)) {
15156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
15157 }
15158 arg1 = reinterpret_cast< wxImage * >(argp1);
15159 {
15160 PyThreadState* __tstate = wxPyBeginAllowThreads();
15161 result = (bool)(arg1)->Ok();
15162 wxPyEndAllowThreads(__tstate);
15163 if (PyErr_Occurred()) SWIG_fail;
15164 }
15165 {
15166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15167 }
15168 return resultobj;
15169 fail:
15170 return NULL;
15171 }
15172
15173
15174 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15175 PyObject *resultobj = 0;
15176 wxImage *arg1 = (wxImage *) 0 ;
15177 int result;
15178 void *argp1 = 0 ;
15179 int res1 = 0 ;
15180 PyObject *swig_obj[1] ;
15181
15182 if (!args) SWIG_fail;
15183 swig_obj[0] = args;
15184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15185 if (!SWIG_IsOK(res1)) {
15186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
15187 }
15188 arg1 = reinterpret_cast< wxImage * >(argp1);
15189 {
15190 PyThreadState* __tstate = wxPyBeginAllowThreads();
15191 result = (int)(arg1)->GetWidth();
15192 wxPyEndAllowThreads(__tstate);
15193 if (PyErr_Occurred()) SWIG_fail;
15194 }
15195 resultobj = SWIG_From_int(static_cast< int >(result));
15196 return resultobj;
15197 fail:
15198 return NULL;
15199 }
15200
15201
15202 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15203 PyObject *resultobj = 0;
15204 wxImage *arg1 = (wxImage *) 0 ;
15205 int result;
15206 void *argp1 = 0 ;
15207 int res1 = 0 ;
15208 PyObject *swig_obj[1] ;
15209
15210 if (!args) SWIG_fail;
15211 swig_obj[0] = args;
15212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15213 if (!SWIG_IsOK(res1)) {
15214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15215 }
15216 arg1 = reinterpret_cast< wxImage * >(argp1);
15217 {
15218 PyThreadState* __tstate = wxPyBeginAllowThreads();
15219 result = (int)(arg1)->GetHeight();
15220 wxPyEndAllowThreads(__tstate);
15221 if (PyErr_Occurred()) SWIG_fail;
15222 }
15223 resultobj = SWIG_From_int(static_cast< int >(result));
15224 return resultobj;
15225 fail:
15226 return NULL;
15227 }
15228
15229
15230 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15231 PyObject *resultobj = 0;
15232 wxImage *arg1 = (wxImage *) 0 ;
15233 wxSize result;
15234 void *argp1 = 0 ;
15235 int res1 = 0 ;
15236 PyObject *swig_obj[1] ;
15237
15238 if (!args) SWIG_fail;
15239 swig_obj[0] = args;
15240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15241 if (!SWIG_IsOK(res1)) {
15242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15243 }
15244 arg1 = reinterpret_cast< wxImage * >(argp1);
15245 {
15246 PyThreadState* __tstate = wxPyBeginAllowThreads();
15247 result = wxImage_GetSize(arg1);
15248 wxPyEndAllowThreads(__tstate);
15249 if (PyErr_Occurred()) SWIG_fail;
15250 }
15251 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15252 return resultobj;
15253 fail:
15254 return NULL;
15255 }
15256
15257
15258 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15259 PyObject *resultobj = 0;
15260 wxImage *arg1 = (wxImage *) 0 ;
15261 wxRect *arg2 = 0 ;
15262 SwigValueWrapper<wxImage > result;
15263 void *argp1 = 0 ;
15264 int res1 = 0 ;
15265 wxRect temp2 ;
15266 PyObject * obj0 = 0 ;
15267 PyObject * obj1 = 0 ;
15268 char * kwnames[] = {
15269 (char *) "self",(char *) "rect", NULL
15270 };
15271
15272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15274 if (!SWIG_IsOK(res1)) {
15275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15276 }
15277 arg1 = reinterpret_cast< wxImage * >(argp1);
15278 {
15279 arg2 = &temp2;
15280 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15281 }
15282 {
15283 PyThreadState* __tstate = wxPyBeginAllowThreads();
15284 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15285 wxPyEndAllowThreads(__tstate);
15286 if (PyErr_Occurred()) SWIG_fail;
15287 }
15288 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15289 return resultobj;
15290 fail:
15291 return NULL;
15292 }
15293
15294
15295 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15296 PyObject *resultobj = 0;
15297 wxImage *arg1 = (wxImage *) 0 ;
15298 wxSize *arg2 = 0 ;
15299 wxPoint *arg3 = 0 ;
15300 int arg4 = (int) -1 ;
15301 int arg5 = (int) -1 ;
15302 int arg6 = (int) -1 ;
15303 SwigValueWrapper<wxImage > result;
15304 void *argp1 = 0 ;
15305 int res1 = 0 ;
15306 wxSize temp2 ;
15307 wxPoint temp3 ;
15308 int val4 ;
15309 int ecode4 = 0 ;
15310 int val5 ;
15311 int ecode5 = 0 ;
15312 int val6 ;
15313 int ecode6 = 0 ;
15314 PyObject * obj0 = 0 ;
15315 PyObject * obj1 = 0 ;
15316 PyObject * obj2 = 0 ;
15317 PyObject * obj3 = 0 ;
15318 PyObject * obj4 = 0 ;
15319 PyObject * obj5 = 0 ;
15320 char * kwnames[] = {
15321 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15322 };
15323
15324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15326 if (!SWIG_IsOK(res1)) {
15327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15328 }
15329 arg1 = reinterpret_cast< wxImage * >(argp1);
15330 {
15331 arg2 = &temp2;
15332 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15333 }
15334 {
15335 arg3 = &temp3;
15336 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15337 }
15338 if (obj3) {
15339 ecode4 = SWIG_AsVal_int(obj3, &val4);
15340 if (!SWIG_IsOK(ecode4)) {
15341 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15342 }
15343 arg4 = static_cast< int >(val4);
15344 }
15345 if (obj4) {
15346 ecode5 = SWIG_AsVal_int(obj4, &val5);
15347 if (!SWIG_IsOK(ecode5)) {
15348 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15349 }
15350 arg5 = static_cast< int >(val5);
15351 }
15352 if (obj5) {
15353 ecode6 = SWIG_AsVal_int(obj5, &val6);
15354 if (!SWIG_IsOK(ecode6)) {
15355 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15356 }
15357 arg6 = static_cast< int >(val6);
15358 }
15359 {
15360 PyThreadState* __tstate = wxPyBeginAllowThreads();
15361 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15362 wxPyEndAllowThreads(__tstate);
15363 if (PyErr_Occurred()) SWIG_fail;
15364 }
15365 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15366 return resultobj;
15367 fail:
15368 return NULL;
15369 }
15370
15371
15372 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15373 PyObject *resultobj = 0;
15374 wxImage *arg1 = (wxImage *) 0 ;
15375 SwigValueWrapper<wxImage > result;
15376 void *argp1 = 0 ;
15377 int res1 = 0 ;
15378 PyObject *swig_obj[1] ;
15379
15380 if (!args) SWIG_fail;
15381 swig_obj[0] = args;
15382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15383 if (!SWIG_IsOK(res1)) {
15384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15385 }
15386 arg1 = reinterpret_cast< wxImage * >(argp1);
15387 {
15388 PyThreadState* __tstate = wxPyBeginAllowThreads();
15389 result = (arg1)->Copy();
15390 wxPyEndAllowThreads(__tstate);
15391 if (PyErr_Occurred()) SWIG_fail;
15392 }
15393 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15394 return resultobj;
15395 fail:
15396 return NULL;
15397 }
15398
15399
15400 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15401 PyObject *resultobj = 0;
15402 wxImage *arg1 = (wxImage *) 0 ;
15403 wxImage *arg2 = 0 ;
15404 int arg3 ;
15405 int arg4 ;
15406 void *argp1 = 0 ;
15407 int res1 = 0 ;
15408 void *argp2 = 0 ;
15409 int res2 = 0 ;
15410 int val3 ;
15411 int ecode3 = 0 ;
15412 int val4 ;
15413 int ecode4 = 0 ;
15414 PyObject * obj0 = 0 ;
15415 PyObject * obj1 = 0 ;
15416 PyObject * obj2 = 0 ;
15417 PyObject * obj3 = 0 ;
15418 char * kwnames[] = {
15419 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15420 };
15421
15422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15424 if (!SWIG_IsOK(res1)) {
15425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15426 }
15427 arg1 = reinterpret_cast< wxImage * >(argp1);
15428 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15429 if (!SWIG_IsOK(res2)) {
15430 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15431 }
15432 if (!argp2) {
15433 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15434 }
15435 arg2 = reinterpret_cast< wxImage * >(argp2);
15436 ecode3 = SWIG_AsVal_int(obj2, &val3);
15437 if (!SWIG_IsOK(ecode3)) {
15438 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15439 }
15440 arg3 = static_cast< int >(val3);
15441 ecode4 = SWIG_AsVal_int(obj3, &val4);
15442 if (!SWIG_IsOK(ecode4)) {
15443 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15444 }
15445 arg4 = static_cast< int >(val4);
15446 {
15447 PyThreadState* __tstate = wxPyBeginAllowThreads();
15448 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15449 wxPyEndAllowThreads(__tstate);
15450 if (PyErr_Occurred()) SWIG_fail;
15451 }
15452 resultobj = SWIG_Py_Void();
15453 return resultobj;
15454 fail:
15455 return NULL;
15456 }
15457
15458
15459 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15460 PyObject *resultobj = 0;
15461 wxImage *arg1 = (wxImage *) 0 ;
15462 PyObject *result = 0 ;
15463 void *argp1 = 0 ;
15464 int res1 = 0 ;
15465 PyObject *swig_obj[1] ;
15466
15467 if (!args) SWIG_fail;
15468 swig_obj[0] = args;
15469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15470 if (!SWIG_IsOK(res1)) {
15471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15472 }
15473 arg1 = reinterpret_cast< wxImage * >(argp1);
15474 {
15475 PyThreadState* __tstate = wxPyBeginAllowThreads();
15476 result = (PyObject *)wxImage_GetData(arg1);
15477 wxPyEndAllowThreads(__tstate);
15478 if (PyErr_Occurred()) SWIG_fail;
15479 }
15480 resultobj = result;
15481 return resultobj;
15482 fail:
15483 return NULL;
15484 }
15485
15486
15487 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15488 PyObject *resultobj = 0;
15489 wxImage *arg1 = (wxImage *) 0 ;
15490 buffer arg2 ;
15491 int arg3 ;
15492 void *argp1 = 0 ;
15493 int res1 = 0 ;
15494 PyObject * obj0 = 0 ;
15495 PyObject * obj1 = 0 ;
15496 char * kwnames[] = {
15497 (char *) "self",(char *) "data", NULL
15498 };
15499
15500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
15501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15502 if (!SWIG_IsOK(res1)) {
15503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
15504 }
15505 arg1 = reinterpret_cast< wxImage * >(argp1);
15506 {
15507 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &arg3) == -1) SWIG_fail;
15508 }
15509 {
15510 PyThreadState* __tstate = wxPyBeginAllowThreads();
15511 wxImage_SetData(arg1,arg2,arg3);
15512 wxPyEndAllowThreads(__tstate);
15513 if (PyErr_Occurred()) SWIG_fail;
15514 }
15515 resultobj = SWIG_Py_Void();
15516 return resultobj;
15517 fail:
15518 return NULL;
15519 }
15520
15521
15522 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15523 PyObject *resultobj = 0;
15524 wxImage *arg1 = (wxImage *) 0 ;
15525 PyObject *result = 0 ;
15526 void *argp1 = 0 ;
15527 int res1 = 0 ;
15528 PyObject *swig_obj[1] ;
15529
15530 if (!args) SWIG_fail;
15531 swig_obj[0] = args;
15532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15533 if (!SWIG_IsOK(res1)) {
15534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15535 }
15536 arg1 = reinterpret_cast< wxImage * >(argp1);
15537 {
15538 PyThreadState* __tstate = wxPyBeginAllowThreads();
15539 result = (PyObject *)wxImage_GetDataBuffer(arg1);
15540 wxPyEndAllowThreads(__tstate);
15541 if (PyErr_Occurred()) SWIG_fail;
15542 }
15543 resultobj = result;
15544 return resultobj;
15545 fail:
15546 return NULL;
15547 }
15548
15549
15550 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15551 PyObject *resultobj = 0;
15552 wxImage *arg1 = (wxImage *) 0 ;
15553 buffer arg2 ;
15554 int arg3 ;
15555 void *argp1 = 0 ;
15556 int res1 = 0 ;
15557 PyObject * obj0 = 0 ;
15558 PyObject * obj1 = 0 ;
15559 char * kwnames[] = {
15560 (char *) "self",(char *) "data", NULL
15561 };
15562
15563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15565 if (!SWIG_IsOK(res1)) {
15566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15567 }
15568 arg1 = reinterpret_cast< wxImage * >(argp1);
15569 {
15570 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &arg3) == -1) SWIG_fail;
15571 }
15572 {
15573 PyThreadState* __tstate = wxPyBeginAllowThreads();
15574 wxImage_SetDataBuffer(arg1,arg2,arg3);
15575 wxPyEndAllowThreads(__tstate);
15576 if (PyErr_Occurred()) SWIG_fail;
15577 }
15578 resultobj = SWIG_Py_Void();
15579 return resultobj;
15580 fail:
15581 return NULL;
15582 }
15583
15584
15585 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15586 PyObject *resultobj = 0;
15587 wxImage *arg1 = (wxImage *) 0 ;
15588 PyObject *result = 0 ;
15589 void *argp1 = 0 ;
15590 int res1 = 0 ;
15591 PyObject *swig_obj[1] ;
15592
15593 if (!args) SWIG_fail;
15594 swig_obj[0] = args;
15595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15596 if (!SWIG_IsOK(res1)) {
15597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15598 }
15599 arg1 = reinterpret_cast< wxImage * >(argp1);
15600 {
15601 PyThreadState* __tstate = wxPyBeginAllowThreads();
15602 result = (PyObject *)wxImage_GetAlphaData(arg1);
15603 wxPyEndAllowThreads(__tstate);
15604 if (PyErr_Occurred()) SWIG_fail;
15605 }
15606 resultobj = result;
15607 return resultobj;
15608 fail:
15609 return NULL;
15610 }
15611
15612
15613 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15614 PyObject *resultobj = 0;
15615 wxImage *arg1 = (wxImage *) 0 ;
15616 buffer arg2 ;
15617 int arg3 ;
15618 void *argp1 = 0 ;
15619 int res1 = 0 ;
15620 PyObject * obj0 = 0 ;
15621 PyObject * obj1 = 0 ;
15622 char * kwnames[] = {
15623 (char *) "self",(char *) "alpha", NULL
15624 };
15625
15626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
15627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15628 if (!SWIG_IsOK(res1)) {
15629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15630 }
15631 arg1 = reinterpret_cast< wxImage * >(argp1);
15632 {
15633 if (obj1 != Py_None) {
15634 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &arg3) == -1) SWIG_fail;
15635 }
15636 }
15637 {
15638 PyThreadState* __tstate = wxPyBeginAllowThreads();
15639 wxImage_SetAlphaData(arg1,arg2,arg3);
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_GetAlphaBuffer(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_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15663 }
15664 arg1 = reinterpret_cast< wxImage * >(argp1);
15665 {
15666 PyThreadState* __tstate = wxPyBeginAllowThreads();
15667 result = (PyObject *)wxImage_GetAlphaBuffer(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_SetAlphaBuffer(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 PyObject * obj0 = 0 ;
15686 PyObject * obj1 = 0 ;
15687 char * kwnames[] = {
15688 (char *) "self",(char *) "alpha", NULL
15689 };
15690
15691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15693 if (!SWIG_IsOK(res1)) {
15694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15695 }
15696 arg1 = reinterpret_cast< wxImage * >(argp1);
15697 {
15698 if (obj1 != Py_None) {
15699 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &arg3) == -1) SWIG_fail;
15700 }
15701 }
15702 {
15703 PyThreadState* __tstate = wxPyBeginAllowThreads();
15704 wxImage_SetAlphaBuffer(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_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15716 PyObject *resultobj = 0;
15717 wxImage *arg1 = (wxImage *) 0 ;
15718 byte arg2 ;
15719 byte arg3 ;
15720 byte arg4 ;
15721 void *argp1 = 0 ;
15722 int res1 = 0 ;
15723 unsigned char val2 ;
15724 int ecode2 = 0 ;
15725 unsigned char val3 ;
15726 int ecode3 = 0 ;
15727 unsigned char val4 ;
15728 int ecode4 = 0 ;
15729 PyObject * obj0 = 0 ;
15730 PyObject * obj1 = 0 ;
15731 PyObject * obj2 = 0 ;
15732 PyObject * obj3 = 0 ;
15733 char * kwnames[] = {
15734 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15735 };
15736
15737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15739 if (!SWIG_IsOK(res1)) {
15740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
15741 }
15742 arg1 = reinterpret_cast< wxImage * >(argp1);
15743 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15744 if (!SWIG_IsOK(ecode2)) {
15745 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
15746 }
15747 arg2 = static_cast< byte >(val2);
15748 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15749 if (!SWIG_IsOK(ecode3)) {
15750 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
15751 }
15752 arg3 = static_cast< byte >(val3);
15753 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15754 if (!SWIG_IsOK(ecode4)) {
15755 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
15756 }
15757 arg4 = static_cast< byte >(val4);
15758 {
15759 PyThreadState* __tstate = wxPyBeginAllowThreads();
15760 (arg1)->SetMaskColour(arg2,arg3,arg4);
15761 wxPyEndAllowThreads(__tstate);
15762 if (PyErr_Occurred()) SWIG_fail;
15763 }
15764 resultobj = SWIG_Py_Void();
15765 return resultobj;
15766 fail:
15767 return NULL;
15768 }
15769
15770
15771 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15772 PyObject *resultobj = 0;
15773 wxImage *arg1 = (wxImage *) 0 ;
15774 byte *arg2 = (byte *) 0 ;
15775 byte *arg3 = (byte *) 0 ;
15776 byte *arg4 = (byte *) 0 ;
15777 void *argp1 = 0 ;
15778 int res1 = 0 ;
15779 byte temp2 ;
15780 int res2 = SWIG_TMPOBJ ;
15781 byte temp3 ;
15782 int res3 = SWIG_TMPOBJ ;
15783 byte temp4 ;
15784 int res4 = SWIG_TMPOBJ ;
15785 PyObject *swig_obj[1] ;
15786
15787 arg2 = &temp2;
15788 arg3 = &temp3;
15789 arg4 = &temp4;
15790 if (!args) SWIG_fail;
15791 swig_obj[0] = args;
15792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15793 if (!SWIG_IsOK(res1)) {
15794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
15795 }
15796 arg1 = reinterpret_cast< wxImage * >(argp1);
15797 {
15798 PyThreadState* __tstate = wxPyBeginAllowThreads();
15799 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
15800 wxPyEndAllowThreads(__tstate);
15801 if (PyErr_Occurred()) SWIG_fail;
15802 }
15803 resultobj = SWIG_Py_Void();
15804 if (SWIG_IsTmpObj(res2)) {
15805 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15806 } else {
15807 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15808 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15809 }
15810 if (SWIG_IsTmpObj(res3)) {
15811 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15812 } else {
15813 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15814 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15815 }
15816 if (SWIG_IsTmpObj(res4)) {
15817 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15818 } else {
15819 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15820 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15821 }
15822 return resultobj;
15823 fail:
15824 return NULL;
15825 }
15826
15827
15828 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15829 PyObject *resultobj = 0;
15830 wxImage *arg1 = (wxImage *) 0 ;
15831 byte result;
15832 void *argp1 = 0 ;
15833 int res1 = 0 ;
15834 PyObject *swig_obj[1] ;
15835
15836 if (!args) SWIG_fail;
15837 swig_obj[0] = args;
15838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15839 if (!SWIG_IsOK(res1)) {
15840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
15841 }
15842 arg1 = reinterpret_cast< wxImage * >(argp1);
15843 {
15844 PyThreadState* __tstate = wxPyBeginAllowThreads();
15845 result = (byte)(arg1)->GetMaskRed();
15846 wxPyEndAllowThreads(__tstate);
15847 if (PyErr_Occurred()) SWIG_fail;
15848 }
15849 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15850 return resultobj;
15851 fail:
15852 return NULL;
15853 }
15854
15855
15856 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15857 PyObject *resultobj = 0;
15858 wxImage *arg1 = (wxImage *) 0 ;
15859 byte result;
15860 void *argp1 = 0 ;
15861 int res1 = 0 ;
15862 PyObject *swig_obj[1] ;
15863
15864 if (!args) SWIG_fail;
15865 swig_obj[0] = args;
15866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15867 if (!SWIG_IsOK(res1)) {
15868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
15869 }
15870 arg1 = reinterpret_cast< wxImage * >(argp1);
15871 {
15872 PyThreadState* __tstate = wxPyBeginAllowThreads();
15873 result = (byte)(arg1)->GetMaskGreen();
15874 wxPyEndAllowThreads(__tstate);
15875 if (PyErr_Occurred()) SWIG_fail;
15876 }
15877 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15878 return resultobj;
15879 fail:
15880 return NULL;
15881 }
15882
15883
15884 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15885 PyObject *resultobj = 0;
15886 wxImage *arg1 = (wxImage *) 0 ;
15887 byte result;
15888 void *argp1 = 0 ;
15889 int res1 = 0 ;
15890 PyObject *swig_obj[1] ;
15891
15892 if (!args) SWIG_fail;
15893 swig_obj[0] = args;
15894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15895 if (!SWIG_IsOK(res1)) {
15896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
15897 }
15898 arg1 = reinterpret_cast< wxImage * >(argp1);
15899 {
15900 PyThreadState* __tstate = wxPyBeginAllowThreads();
15901 result = (byte)(arg1)->GetMaskBlue();
15902 wxPyEndAllowThreads(__tstate);
15903 if (PyErr_Occurred()) SWIG_fail;
15904 }
15905 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15906 return resultobj;
15907 fail:
15908 return NULL;
15909 }
15910
15911
15912 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15913 PyObject *resultobj = 0;
15914 wxImage *arg1 = (wxImage *) 0 ;
15915 bool arg2 = (bool) true ;
15916 void *argp1 = 0 ;
15917 int res1 = 0 ;
15918 bool val2 ;
15919 int ecode2 = 0 ;
15920 PyObject * obj0 = 0 ;
15921 PyObject * obj1 = 0 ;
15922 char * kwnames[] = {
15923 (char *) "self",(char *) "mask", NULL
15924 };
15925
15926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
15927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15928 if (!SWIG_IsOK(res1)) {
15929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
15930 }
15931 arg1 = reinterpret_cast< wxImage * >(argp1);
15932 if (obj1) {
15933 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15934 if (!SWIG_IsOK(ecode2)) {
15935 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
15936 }
15937 arg2 = static_cast< bool >(val2);
15938 }
15939 {
15940 PyThreadState* __tstate = wxPyBeginAllowThreads();
15941 (arg1)->SetMask(arg2);
15942 wxPyEndAllowThreads(__tstate);
15943 if (PyErr_Occurred()) SWIG_fail;
15944 }
15945 resultobj = SWIG_Py_Void();
15946 return resultobj;
15947 fail:
15948 return NULL;
15949 }
15950
15951
15952 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15953 PyObject *resultobj = 0;
15954 wxImage *arg1 = (wxImage *) 0 ;
15955 bool result;
15956 void *argp1 = 0 ;
15957 int res1 = 0 ;
15958 PyObject *swig_obj[1] ;
15959
15960 if (!args) SWIG_fail;
15961 swig_obj[0] = args;
15962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15963 if (!SWIG_IsOK(res1)) {
15964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
15965 }
15966 arg1 = reinterpret_cast< wxImage * >(argp1);
15967 {
15968 PyThreadState* __tstate = wxPyBeginAllowThreads();
15969 result = (bool)(arg1)->HasMask();
15970 wxPyEndAllowThreads(__tstate);
15971 if (PyErr_Occurred()) SWIG_fail;
15972 }
15973 {
15974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15975 }
15976 return resultobj;
15977 fail:
15978 return NULL;
15979 }
15980
15981
15982 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15983 PyObject *resultobj = 0;
15984 wxImage *arg1 = (wxImage *) 0 ;
15985 double arg2 ;
15986 wxPoint *arg3 = 0 ;
15987 bool arg4 = (bool) true ;
15988 wxPoint *arg5 = (wxPoint *) NULL ;
15989 SwigValueWrapper<wxImage > result;
15990 void *argp1 = 0 ;
15991 int res1 = 0 ;
15992 double val2 ;
15993 int ecode2 = 0 ;
15994 wxPoint temp3 ;
15995 bool val4 ;
15996 int ecode4 = 0 ;
15997 void *argp5 = 0 ;
15998 int res5 = 0 ;
15999 PyObject * obj0 = 0 ;
16000 PyObject * obj1 = 0 ;
16001 PyObject * obj2 = 0 ;
16002 PyObject * obj3 = 0 ;
16003 PyObject * obj4 = 0 ;
16004 char * kwnames[] = {
16005 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
16006 };
16007
16008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16010 if (!SWIG_IsOK(res1)) {
16011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
16012 }
16013 arg1 = reinterpret_cast< wxImage * >(argp1);
16014 ecode2 = SWIG_AsVal_double(obj1, &val2);
16015 if (!SWIG_IsOK(ecode2)) {
16016 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
16017 }
16018 arg2 = static_cast< double >(val2);
16019 {
16020 arg3 = &temp3;
16021 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
16022 }
16023 if (obj3) {
16024 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16025 if (!SWIG_IsOK(ecode4)) {
16026 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
16027 }
16028 arg4 = static_cast< bool >(val4);
16029 }
16030 if (obj4) {
16031 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
16032 if (!SWIG_IsOK(res5)) {
16033 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
16034 }
16035 arg5 = reinterpret_cast< wxPoint * >(argp5);
16036 }
16037 {
16038 PyThreadState* __tstate = wxPyBeginAllowThreads();
16039 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
16040 wxPyEndAllowThreads(__tstate);
16041 if (PyErr_Occurred()) SWIG_fail;
16042 }
16043 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16044 return resultobj;
16045 fail:
16046 return NULL;
16047 }
16048
16049
16050 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16051 PyObject *resultobj = 0;
16052 wxImage *arg1 = (wxImage *) 0 ;
16053 bool arg2 = (bool) true ;
16054 SwigValueWrapper<wxImage > result;
16055 void *argp1 = 0 ;
16056 int res1 = 0 ;
16057 bool val2 ;
16058 int ecode2 = 0 ;
16059 PyObject * obj0 = 0 ;
16060 PyObject * obj1 = 0 ;
16061 char * kwnames[] = {
16062 (char *) "self",(char *) "clockwise", NULL
16063 };
16064
16065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
16066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16067 if (!SWIG_IsOK(res1)) {
16068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
16069 }
16070 arg1 = reinterpret_cast< wxImage * >(argp1);
16071 if (obj1) {
16072 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16073 if (!SWIG_IsOK(ecode2)) {
16074 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
16075 }
16076 arg2 = static_cast< bool >(val2);
16077 }
16078 {
16079 PyThreadState* __tstate = wxPyBeginAllowThreads();
16080 result = (arg1)->Rotate90(arg2);
16081 wxPyEndAllowThreads(__tstate);
16082 if (PyErr_Occurred()) SWIG_fail;
16083 }
16084 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16085 return resultobj;
16086 fail:
16087 return NULL;
16088 }
16089
16090
16091 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16092 PyObject *resultobj = 0;
16093 wxImage *arg1 = (wxImage *) 0 ;
16094 bool arg2 = (bool) true ;
16095 SwigValueWrapper<wxImage > result;
16096 void *argp1 = 0 ;
16097 int res1 = 0 ;
16098 bool val2 ;
16099 int ecode2 = 0 ;
16100 PyObject * obj0 = 0 ;
16101 PyObject * obj1 = 0 ;
16102 char * kwnames[] = {
16103 (char *) "self",(char *) "horizontally", NULL
16104 };
16105
16106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
16107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16108 if (!SWIG_IsOK(res1)) {
16109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
16110 }
16111 arg1 = reinterpret_cast< wxImage * >(argp1);
16112 if (obj1) {
16113 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16114 if (!SWIG_IsOK(ecode2)) {
16115 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
16116 }
16117 arg2 = static_cast< bool >(val2);
16118 }
16119 {
16120 PyThreadState* __tstate = wxPyBeginAllowThreads();
16121 result = (arg1)->Mirror(arg2);
16122 wxPyEndAllowThreads(__tstate);
16123 if (PyErr_Occurred()) SWIG_fail;
16124 }
16125 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16126 return resultobj;
16127 fail:
16128 return NULL;
16129 }
16130
16131
16132 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16133 PyObject *resultobj = 0;
16134 wxImage *arg1 = (wxImage *) 0 ;
16135 byte arg2 ;
16136 byte arg3 ;
16137 byte arg4 ;
16138 byte arg5 ;
16139 byte arg6 ;
16140 byte arg7 ;
16141 void *argp1 = 0 ;
16142 int res1 = 0 ;
16143 unsigned char val2 ;
16144 int ecode2 = 0 ;
16145 unsigned char val3 ;
16146 int ecode3 = 0 ;
16147 unsigned char val4 ;
16148 int ecode4 = 0 ;
16149 unsigned char val5 ;
16150 int ecode5 = 0 ;
16151 unsigned char val6 ;
16152 int ecode6 = 0 ;
16153 unsigned char val7 ;
16154 int ecode7 = 0 ;
16155 PyObject * obj0 = 0 ;
16156 PyObject * obj1 = 0 ;
16157 PyObject * obj2 = 0 ;
16158 PyObject * obj3 = 0 ;
16159 PyObject * obj4 = 0 ;
16160 PyObject * obj5 = 0 ;
16161 PyObject * obj6 = 0 ;
16162 char * kwnames[] = {
16163 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
16164 };
16165
16166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
16167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16168 if (!SWIG_IsOK(res1)) {
16169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
16170 }
16171 arg1 = reinterpret_cast< wxImage * >(argp1);
16172 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16173 if (!SWIG_IsOK(ecode2)) {
16174 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
16175 }
16176 arg2 = static_cast< byte >(val2);
16177 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16178 if (!SWIG_IsOK(ecode3)) {
16179 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
16180 }
16181 arg3 = static_cast< byte >(val3);
16182 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16183 if (!SWIG_IsOK(ecode4)) {
16184 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
16185 }
16186 arg4 = static_cast< byte >(val4);
16187 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16188 if (!SWIG_IsOK(ecode5)) {
16189 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
16190 }
16191 arg5 = static_cast< byte >(val5);
16192 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16193 if (!SWIG_IsOK(ecode6)) {
16194 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16195 }
16196 arg6 = static_cast< byte >(val6);
16197 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16198 if (!SWIG_IsOK(ecode7)) {
16199 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16200 }
16201 arg7 = static_cast< byte >(val7);
16202 {
16203 PyThreadState* __tstate = wxPyBeginAllowThreads();
16204 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16205 wxPyEndAllowThreads(__tstate);
16206 if (PyErr_Occurred()) SWIG_fail;
16207 }
16208 resultobj = SWIG_Py_Void();
16209 return resultobj;
16210 fail:
16211 return NULL;
16212 }
16213
16214
16215 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16216 PyObject *resultobj = 0;
16217 wxImage *arg1 = (wxImage *) 0 ;
16218 double arg2 = (double) 0.299 ;
16219 double arg3 = (double) 0.587 ;
16220 double arg4 = (double) 0.114 ;
16221 SwigValueWrapper<wxImage > result;
16222 void *argp1 = 0 ;
16223 int res1 = 0 ;
16224 double val2 ;
16225 int ecode2 = 0 ;
16226 double val3 ;
16227 int ecode3 = 0 ;
16228 double val4 ;
16229 int ecode4 = 0 ;
16230 PyObject * obj0 = 0 ;
16231 PyObject * obj1 = 0 ;
16232 PyObject * obj2 = 0 ;
16233 PyObject * obj3 = 0 ;
16234 char * kwnames[] = {
16235 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16236 };
16237
16238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16240 if (!SWIG_IsOK(res1)) {
16241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16242 }
16243 arg1 = reinterpret_cast< wxImage * >(argp1);
16244 if (obj1) {
16245 ecode2 = SWIG_AsVal_double(obj1, &val2);
16246 if (!SWIG_IsOK(ecode2)) {
16247 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16248 }
16249 arg2 = static_cast< double >(val2);
16250 }
16251 if (obj2) {
16252 ecode3 = SWIG_AsVal_double(obj2, &val3);
16253 if (!SWIG_IsOK(ecode3)) {
16254 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16255 }
16256 arg3 = static_cast< double >(val3);
16257 }
16258 if (obj3) {
16259 ecode4 = SWIG_AsVal_double(obj3, &val4);
16260 if (!SWIG_IsOK(ecode4)) {
16261 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16262 }
16263 arg4 = static_cast< double >(val4);
16264 }
16265 {
16266 PyThreadState* __tstate = wxPyBeginAllowThreads();
16267 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16268 wxPyEndAllowThreads(__tstate);
16269 if (PyErr_Occurred()) SWIG_fail;
16270 }
16271 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16272 return resultobj;
16273 fail:
16274 return NULL;
16275 }
16276
16277
16278 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16279 PyObject *resultobj = 0;
16280 wxImage *arg1 = (wxImage *) 0 ;
16281 byte arg2 ;
16282 byte arg3 ;
16283 byte arg4 ;
16284 SwigValueWrapper<wxImage > result;
16285 void *argp1 = 0 ;
16286 int res1 = 0 ;
16287 unsigned char val2 ;
16288 int ecode2 = 0 ;
16289 unsigned char val3 ;
16290 int ecode3 = 0 ;
16291 unsigned char val4 ;
16292 int ecode4 = 0 ;
16293 PyObject * obj0 = 0 ;
16294 PyObject * obj1 = 0 ;
16295 PyObject * obj2 = 0 ;
16296 PyObject * obj3 = 0 ;
16297 char * kwnames[] = {
16298 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16299 };
16300
16301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16303 if (!SWIG_IsOK(res1)) {
16304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16305 }
16306 arg1 = reinterpret_cast< wxImage * >(argp1);
16307 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16308 if (!SWIG_IsOK(ecode2)) {
16309 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16310 }
16311 arg2 = static_cast< byte >(val2);
16312 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16313 if (!SWIG_IsOK(ecode3)) {
16314 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16315 }
16316 arg3 = static_cast< byte >(val3);
16317 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16318 if (!SWIG_IsOK(ecode4)) {
16319 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16320 }
16321 arg4 = static_cast< byte >(val4);
16322 {
16323 PyThreadState* __tstate = wxPyBeginAllowThreads();
16324 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16325 wxPyEndAllowThreads(__tstate);
16326 if (PyErr_Occurred()) SWIG_fail;
16327 }
16328 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16329 return resultobj;
16330 fail:
16331 return NULL;
16332 }
16333
16334
16335 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16336 PyObject *resultobj = 0;
16337 wxImage *arg1 = (wxImage *) 0 ;
16338 wxString *arg2 = 0 ;
16339 wxString *arg3 = 0 ;
16340 void *argp1 = 0 ;
16341 int res1 = 0 ;
16342 bool temp2 = false ;
16343 bool temp3 = false ;
16344 PyObject * obj0 = 0 ;
16345 PyObject * obj1 = 0 ;
16346 PyObject * obj2 = 0 ;
16347 char * kwnames[] = {
16348 (char *) "self",(char *) "name",(char *) "value", NULL
16349 };
16350
16351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16353 if (!SWIG_IsOK(res1)) {
16354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16355 }
16356 arg1 = reinterpret_cast< wxImage * >(argp1);
16357 {
16358 arg2 = wxString_in_helper(obj1);
16359 if (arg2 == NULL) SWIG_fail;
16360 temp2 = true;
16361 }
16362 {
16363 arg3 = wxString_in_helper(obj2);
16364 if (arg3 == NULL) SWIG_fail;
16365 temp3 = true;
16366 }
16367 {
16368 PyThreadState* __tstate = wxPyBeginAllowThreads();
16369 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16370 wxPyEndAllowThreads(__tstate);
16371 if (PyErr_Occurred()) SWIG_fail;
16372 }
16373 resultobj = SWIG_Py_Void();
16374 {
16375 if (temp2)
16376 delete arg2;
16377 }
16378 {
16379 if (temp3)
16380 delete arg3;
16381 }
16382 return resultobj;
16383 fail:
16384 {
16385 if (temp2)
16386 delete arg2;
16387 }
16388 {
16389 if (temp3)
16390 delete arg3;
16391 }
16392 return NULL;
16393 }
16394
16395
16396 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16397 PyObject *resultobj = 0;
16398 wxImage *arg1 = (wxImage *) 0 ;
16399 wxString *arg2 = 0 ;
16400 int arg3 ;
16401 void *argp1 = 0 ;
16402 int res1 = 0 ;
16403 bool temp2 = false ;
16404 int val3 ;
16405 int ecode3 = 0 ;
16406 PyObject * obj0 = 0 ;
16407 PyObject * obj1 = 0 ;
16408 PyObject * obj2 = 0 ;
16409 char * kwnames[] = {
16410 (char *) "self",(char *) "name",(char *) "value", NULL
16411 };
16412
16413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16415 if (!SWIG_IsOK(res1)) {
16416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16417 }
16418 arg1 = reinterpret_cast< wxImage * >(argp1);
16419 {
16420 arg2 = wxString_in_helper(obj1);
16421 if (arg2 == NULL) SWIG_fail;
16422 temp2 = true;
16423 }
16424 ecode3 = SWIG_AsVal_int(obj2, &val3);
16425 if (!SWIG_IsOK(ecode3)) {
16426 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16427 }
16428 arg3 = static_cast< int >(val3);
16429 {
16430 PyThreadState* __tstate = wxPyBeginAllowThreads();
16431 (arg1)->SetOption((wxString const &)*arg2,arg3);
16432 wxPyEndAllowThreads(__tstate);
16433 if (PyErr_Occurred()) SWIG_fail;
16434 }
16435 resultobj = SWIG_Py_Void();
16436 {
16437 if (temp2)
16438 delete arg2;
16439 }
16440 return resultobj;
16441 fail:
16442 {
16443 if (temp2)
16444 delete arg2;
16445 }
16446 return NULL;
16447 }
16448
16449
16450 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16451 PyObject *resultobj = 0;
16452 wxImage *arg1 = (wxImage *) 0 ;
16453 wxString *arg2 = 0 ;
16454 wxString result;
16455 void *argp1 = 0 ;
16456 int res1 = 0 ;
16457 bool temp2 = false ;
16458 PyObject * obj0 = 0 ;
16459 PyObject * obj1 = 0 ;
16460 char * kwnames[] = {
16461 (char *) "self",(char *) "name", NULL
16462 };
16463
16464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16466 if (!SWIG_IsOK(res1)) {
16467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16468 }
16469 arg1 = reinterpret_cast< wxImage * >(argp1);
16470 {
16471 arg2 = wxString_in_helper(obj1);
16472 if (arg2 == NULL) SWIG_fail;
16473 temp2 = true;
16474 }
16475 {
16476 PyThreadState* __tstate = wxPyBeginAllowThreads();
16477 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16478 wxPyEndAllowThreads(__tstate);
16479 if (PyErr_Occurred()) SWIG_fail;
16480 }
16481 {
16482 #if wxUSE_UNICODE
16483 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16484 #else
16485 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16486 #endif
16487 }
16488 {
16489 if (temp2)
16490 delete arg2;
16491 }
16492 return resultobj;
16493 fail:
16494 {
16495 if (temp2)
16496 delete arg2;
16497 }
16498 return NULL;
16499 }
16500
16501
16502 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16503 PyObject *resultobj = 0;
16504 wxImage *arg1 = (wxImage *) 0 ;
16505 wxString *arg2 = 0 ;
16506 int result;
16507 void *argp1 = 0 ;
16508 int res1 = 0 ;
16509 bool temp2 = false ;
16510 PyObject * obj0 = 0 ;
16511 PyObject * obj1 = 0 ;
16512 char * kwnames[] = {
16513 (char *) "self",(char *) "name", NULL
16514 };
16515
16516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
16517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16518 if (!SWIG_IsOK(res1)) {
16519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
16520 }
16521 arg1 = reinterpret_cast< wxImage * >(argp1);
16522 {
16523 arg2 = wxString_in_helper(obj1);
16524 if (arg2 == NULL) SWIG_fail;
16525 temp2 = true;
16526 }
16527 {
16528 PyThreadState* __tstate = wxPyBeginAllowThreads();
16529 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
16530 wxPyEndAllowThreads(__tstate);
16531 if (PyErr_Occurred()) SWIG_fail;
16532 }
16533 resultobj = SWIG_From_int(static_cast< int >(result));
16534 {
16535 if (temp2)
16536 delete arg2;
16537 }
16538 return resultobj;
16539 fail:
16540 {
16541 if (temp2)
16542 delete arg2;
16543 }
16544 return NULL;
16545 }
16546
16547
16548 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16549 PyObject *resultobj = 0;
16550 wxImage *arg1 = (wxImage *) 0 ;
16551 wxString *arg2 = 0 ;
16552 bool result;
16553 void *argp1 = 0 ;
16554 int res1 = 0 ;
16555 bool temp2 = false ;
16556 PyObject * obj0 = 0 ;
16557 PyObject * obj1 = 0 ;
16558 char * kwnames[] = {
16559 (char *) "self",(char *) "name", NULL
16560 };
16561
16562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
16563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16564 if (!SWIG_IsOK(res1)) {
16565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16566 }
16567 arg1 = reinterpret_cast< wxImage * >(argp1);
16568 {
16569 arg2 = wxString_in_helper(obj1);
16570 if (arg2 == NULL) SWIG_fail;
16571 temp2 = true;
16572 }
16573 {
16574 PyThreadState* __tstate = wxPyBeginAllowThreads();
16575 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
16576 wxPyEndAllowThreads(__tstate);
16577 if (PyErr_Occurred()) SWIG_fail;
16578 }
16579 {
16580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16581 }
16582 {
16583 if (temp2)
16584 delete arg2;
16585 }
16586 return resultobj;
16587 fail:
16588 {
16589 if (temp2)
16590 delete arg2;
16591 }
16592 return NULL;
16593 }
16594
16595
16596 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16597 PyObject *resultobj = 0;
16598 wxImage *arg1 = (wxImage *) 0 ;
16599 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
16600 unsigned long result;
16601 void *argp1 = 0 ;
16602 int res1 = 0 ;
16603 unsigned long val2 ;
16604 int ecode2 = 0 ;
16605 PyObject * obj0 = 0 ;
16606 PyObject * obj1 = 0 ;
16607 char * kwnames[] = {
16608 (char *) "self",(char *) "stopafter", NULL
16609 };
16610
16611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
16612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16613 if (!SWIG_IsOK(res1)) {
16614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
16615 }
16616 arg1 = reinterpret_cast< wxImage * >(argp1);
16617 if (obj1) {
16618 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
16619 if (!SWIG_IsOK(ecode2)) {
16620 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
16621 }
16622 arg2 = static_cast< unsigned long >(val2);
16623 }
16624 {
16625 PyThreadState* __tstate = wxPyBeginAllowThreads();
16626 result = (unsigned long)(arg1)->CountColours(arg2);
16627 wxPyEndAllowThreads(__tstate);
16628 if (PyErr_Occurred()) SWIG_fail;
16629 }
16630 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16631 return resultobj;
16632 fail:
16633 return NULL;
16634 }
16635
16636
16637 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16638 PyObject *resultobj = 0;
16639 wxImage *arg1 = (wxImage *) 0 ;
16640 wxImageHistogram *arg2 = 0 ;
16641 unsigned long result;
16642 void *argp1 = 0 ;
16643 int res1 = 0 ;
16644 void *argp2 = 0 ;
16645 int res2 = 0 ;
16646 PyObject * obj0 = 0 ;
16647 PyObject * obj1 = 0 ;
16648 char * kwnames[] = {
16649 (char *) "self",(char *) "h", NULL
16650 };
16651
16652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
16653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16654 if (!SWIG_IsOK(res1)) {
16655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
16656 }
16657 arg1 = reinterpret_cast< wxImage * >(argp1);
16658 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
16659 if (!SWIG_IsOK(res2)) {
16660 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16661 }
16662 if (!argp2) {
16663 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16664 }
16665 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
16666 {
16667 PyThreadState* __tstate = wxPyBeginAllowThreads();
16668 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
16669 wxPyEndAllowThreads(__tstate);
16670 if (PyErr_Occurred()) SWIG_fail;
16671 }
16672 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16673 return resultobj;
16674 fail:
16675 return NULL;
16676 }
16677
16678
16679 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16680 PyObject *resultobj = 0;
16681 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16682 void *argp1 = 0 ;
16683 int res1 = 0 ;
16684 PyObject * obj0 = 0 ;
16685 char * kwnames[] = {
16686 (char *) "handler", NULL
16687 };
16688
16689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
16690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16691 if (!SWIG_IsOK(res1)) {
16692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16693 }
16694 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16695 {
16696 PyThreadState* __tstate = wxPyBeginAllowThreads();
16697 wxImage::AddHandler(arg1);
16698 wxPyEndAllowThreads(__tstate);
16699 if (PyErr_Occurred()) SWIG_fail;
16700 }
16701 resultobj = SWIG_Py_Void();
16702 return resultobj;
16703 fail:
16704 return NULL;
16705 }
16706
16707
16708 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16709 PyObject *resultobj = 0;
16710 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16711 void *argp1 = 0 ;
16712 int res1 = 0 ;
16713 PyObject * obj0 = 0 ;
16714 char * kwnames[] = {
16715 (char *) "handler", NULL
16716 };
16717
16718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
16719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16720 if (!SWIG_IsOK(res1)) {
16721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16722 }
16723 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16724 {
16725 PyThreadState* __tstate = wxPyBeginAllowThreads();
16726 wxImage::InsertHandler(arg1);
16727 wxPyEndAllowThreads(__tstate);
16728 if (PyErr_Occurred()) SWIG_fail;
16729 }
16730 resultobj = SWIG_Py_Void();
16731 return resultobj;
16732 fail:
16733 return NULL;
16734 }
16735
16736
16737 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16738 PyObject *resultobj = 0;
16739 wxString *arg1 = 0 ;
16740 bool result;
16741 bool temp1 = false ;
16742 PyObject * obj0 = 0 ;
16743 char * kwnames[] = {
16744 (char *) "name", NULL
16745 };
16746
16747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
16748 {
16749 arg1 = wxString_in_helper(obj0);
16750 if (arg1 == NULL) SWIG_fail;
16751 temp1 = true;
16752 }
16753 {
16754 PyThreadState* __tstate = wxPyBeginAllowThreads();
16755 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
16756 wxPyEndAllowThreads(__tstate);
16757 if (PyErr_Occurred()) SWIG_fail;
16758 }
16759 {
16760 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16761 }
16762 {
16763 if (temp1)
16764 delete arg1;
16765 }
16766 return resultobj;
16767 fail:
16768 {
16769 if (temp1)
16770 delete arg1;
16771 }
16772 return NULL;
16773 }
16774
16775
16776 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16777 PyObject *resultobj = 0;
16778 PyObject *result = 0 ;
16779
16780 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
16781 {
16782 PyThreadState* __tstate = wxPyBeginAllowThreads();
16783 result = (PyObject *)wxImage_GetHandlers();
16784 wxPyEndAllowThreads(__tstate);
16785 if (PyErr_Occurred()) SWIG_fail;
16786 }
16787 resultobj = result;
16788 return resultobj;
16789 fail:
16790 return NULL;
16791 }
16792
16793
16794 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16795 PyObject *resultobj = 0;
16796 wxString result;
16797
16798 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
16799 {
16800 PyThreadState* __tstate = wxPyBeginAllowThreads();
16801 result = wxImage::GetImageExtWildcard();
16802 wxPyEndAllowThreads(__tstate);
16803 if (PyErr_Occurred()) SWIG_fail;
16804 }
16805 {
16806 #if wxUSE_UNICODE
16807 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16808 #else
16809 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16810 #endif
16811 }
16812 return resultobj;
16813 fail:
16814 return NULL;
16815 }
16816
16817
16818 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16819 PyObject *resultobj = 0;
16820 wxImage *arg1 = (wxImage *) 0 ;
16821 int arg2 = (int) -1 ;
16822 wxBitmap result;
16823 void *argp1 = 0 ;
16824 int res1 = 0 ;
16825 int val2 ;
16826 int ecode2 = 0 ;
16827 PyObject * obj0 = 0 ;
16828 PyObject * obj1 = 0 ;
16829 char * kwnames[] = {
16830 (char *) "self",(char *) "depth", NULL
16831 };
16832
16833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
16834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16835 if (!SWIG_IsOK(res1)) {
16836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16837 }
16838 arg1 = reinterpret_cast< wxImage * >(argp1);
16839 if (obj1) {
16840 ecode2 = SWIG_AsVal_int(obj1, &val2);
16841 if (!SWIG_IsOK(ecode2)) {
16842 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
16843 }
16844 arg2 = static_cast< int >(val2);
16845 }
16846 {
16847 if (!wxPyCheckForApp()) SWIG_fail;
16848 PyThreadState* __tstate = wxPyBeginAllowThreads();
16849 result = wxImage_ConvertToBitmap(arg1,arg2);
16850 wxPyEndAllowThreads(__tstate);
16851 if (PyErr_Occurred()) SWIG_fail;
16852 }
16853 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16854 return resultobj;
16855 fail:
16856 return NULL;
16857 }
16858
16859
16860 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16861 PyObject *resultobj = 0;
16862 wxImage *arg1 = (wxImage *) 0 ;
16863 byte arg2 ;
16864 byte arg3 ;
16865 byte arg4 ;
16866 wxBitmap result;
16867 void *argp1 = 0 ;
16868 int res1 = 0 ;
16869 unsigned char val2 ;
16870 int ecode2 = 0 ;
16871 unsigned char val3 ;
16872 int ecode3 = 0 ;
16873 unsigned char val4 ;
16874 int ecode4 = 0 ;
16875 PyObject * obj0 = 0 ;
16876 PyObject * obj1 = 0 ;
16877 PyObject * obj2 = 0 ;
16878 PyObject * obj3 = 0 ;
16879 char * kwnames[] = {
16880 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
16881 };
16882
16883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16885 if (!SWIG_IsOK(res1)) {
16886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16887 }
16888 arg1 = reinterpret_cast< wxImage * >(argp1);
16889 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16890 if (!SWIG_IsOK(ecode2)) {
16891 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
16892 }
16893 arg2 = static_cast< byte >(val2);
16894 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16895 if (!SWIG_IsOK(ecode3)) {
16896 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
16897 }
16898 arg3 = static_cast< byte >(val3);
16899 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16900 if (!SWIG_IsOK(ecode4)) {
16901 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
16902 }
16903 arg4 = static_cast< byte >(val4);
16904 {
16905 if (!wxPyCheckForApp()) SWIG_fail;
16906 PyThreadState* __tstate = wxPyBeginAllowThreads();
16907 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
16908 wxPyEndAllowThreads(__tstate);
16909 if (PyErr_Occurred()) SWIG_fail;
16910 }
16911 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16912 return resultobj;
16913 fail:
16914 return NULL;
16915 }
16916
16917
16918 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16919 PyObject *resultobj = 0;
16920 wxImage *arg1 = (wxImage *) 0 ;
16921 double arg2 ;
16922 void *argp1 = 0 ;
16923 int res1 = 0 ;
16924 double val2 ;
16925 int ecode2 = 0 ;
16926 PyObject * obj0 = 0 ;
16927 PyObject * obj1 = 0 ;
16928 char * kwnames[] = {
16929 (char *) "self",(char *) "angle", NULL
16930 };
16931
16932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
16933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16934 if (!SWIG_IsOK(res1)) {
16935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
16936 }
16937 arg1 = reinterpret_cast< wxImage * >(argp1);
16938 ecode2 = SWIG_AsVal_double(obj1, &val2);
16939 if (!SWIG_IsOK(ecode2)) {
16940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
16941 }
16942 arg2 = static_cast< double >(val2);
16943 {
16944 PyThreadState* __tstate = wxPyBeginAllowThreads();
16945 (arg1)->RotateHue(arg2);
16946 wxPyEndAllowThreads(__tstate);
16947 if (PyErr_Occurred()) SWIG_fail;
16948 }
16949 resultobj = SWIG_Py_Void();
16950 return resultobj;
16951 fail:
16952 return NULL;
16953 }
16954
16955
16956 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16957 PyObject *resultobj = 0;
16958 wxImage_RGBValue arg1 ;
16959 wxImage_HSVValue result;
16960 void *argp1 ;
16961 int res1 = 0 ;
16962 PyObject * obj0 = 0 ;
16963 char * kwnames[] = {
16964 (char *) "rgb", NULL
16965 };
16966
16967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
16968 {
16969 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
16970 if (!SWIG_IsOK(res1)) {
16971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16972 }
16973 if (!argp1) {
16974 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16975 } else {
16976 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
16977 arg1 = *temp;
16978 if (SWIG_IsNewObj(res1)) delete temp;
16979 }
16980 }
16981 {
16982 PyThreadState* __tstate = wxPyBeginAllowThreads();
16983 result = wxImage::RGBtoHSV(arg1);
16984 wxPyEndAllowThreads(__tstate);
16985 if (PyErr_Occurred()) SWIG_fail;
16986 }
16987 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
16988 return resultobj;
16989 fail:
16990 return NULL;
16991 }
16992
16993
16994 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16995 PyObject *resultobj = 0;
16996 wxImage_HSVValue arg1 ;
16997 wxImage_RGBValue result;
16998 void *argp1 ;
16999 int res1 = 0 ;
17000 PyObject * obj0 = 0 ;
17001 char * kwnames[] = {
17002 (char *) "hsv", NULL
17003 };
17004
17005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
17006 {
17007 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
17008 if (!SWIG_IsOK(res1)) {
17009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
17010 }
17011 if (!argp1) {
17012 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
17013 } else {
17014 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
17015 arg1 = *temp;
17016 if (SWIG_IsNewObj(res1)) delete temp;
17017 }
17018 }
17019 {
17020 PyThreadState* __tstate = wxPyBeginAllowThreads();
17021 result = wxImage::HSVtoRGB(arg1);
17022 wxPyEndAllowThreads(__tstate);
17023 if (PyErr_Occurred()) SWIG_fail;
17024 }
17025 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
17026 return resultobj;
17027 fail:
17028 return NULL;
17029 }
17030
17031
17032 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17033 PyObject *obj;
17034 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17035 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
17036 return SWIG_Py_Void();
17037 }
17038
17039 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17040 return SWIG_Python_InitShadowInstance(args);
17041 }
17042
17043 SWIGINTERN PyObject *_wrap__ImageFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17044 PyObject *resultobj = 0;
17045 int arg1 ;
17046 int arg2 ;
17047 buffer arg3 ;
17048 int arg4 ;
17049 buffer arg5 = (buffer) NULL ;
17050 int arg6 = (int) 0 ;
17051 wxImage *result = 0 ;
17052 int val1 ;
17053 int ecode1 = 0 ;
17054 int val2 ;
17055 int ecode2 = 0 ;
17056 PyObject * obj0 = 0 ;
17057 PyObject * obj1 = 0 ;
17058 PyObject * obj2 = 0 ;
17059 PyObject * obj3 = 0 ;
17060 char * kwnames[] = {
17061 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
17062 };
17063
17064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:_ImageFromBuffer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17065 ecode1 = SWIG_AsVal_int(obj0, &val1);
17066 if (!SWIG_IsOK(ecode1)) {
17067 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_ImageFromBuffer" "', expected argument " "1"" of type '" "int""'");
17068 }
17069 arg1 = static_cast< int >(val1);
17070 ecode2 = SWIG_AsVal_int(obj1, &val2);
17071 if (!SWIG_IsOK(ecode2)) {
17072 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ImageFromBuffer" "', expected argument " "2"" of type '" "int""'");
17073 }
17074 arg2 = static_cast< int >(val2);
17075 {
17076 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &arg4) == -1) SWIG_fail;
17077 }
17078 if (obj3) {
17079 {
17080 if (obj3 != Py_None) {
17081 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &arg6) == -1) SWIG_fail;
17082 }
17083 }
17084 }
17085 {
17086 PyThreadState* __tstate = wxPyBeginAllowThreads();
17087 result = (wxImage *)_ImageFromBuffer(arg1,arg2,arg3,arg4,arg5,arg6);
17088 wxPyEndAllowThreads(__tstate);
17089 if (PyErr_Occurred()) SWIG_fail;
17090 }
17091 {
17092 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
17093 }
17094 return resultobj;
17095 fail:
17096 return NULL;
17097 }
17098
17099
17100 SWIGINTERN int NullImage_set(PyObject *) {
17101 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
17102 return 1;
17103 }
17104
17105
17106 SWIGINTERN PyObject *NullImage_get(void) {
17107 PyObject *pyobj = 0;
17108
17109 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
17110 return pyobj;
17111 }
17112
17113
17114 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
17115 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
17116 return 1;
17117 }
17118
17119
17120 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
17121 PyObject *pyobj = 0;
17122
17123 {
17124 #if wxUSE_UNICODE
17125 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17126 #else
17127 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17128 #endif
17129 }
17130 return pyobj;
17131 }
17132
17133
17134 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
17135 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
17136 return 1;
17137 }
17138
17139
17140 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
17141 PyObject *pyobj = 0;
17142
17143 {
17144 #if wxUSE_UNICODE
17145 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17146 #else
17147 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17148 #endif
17149 }
17150 return pyobj;
17151 }
17152
17153
17154 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
17155 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
17156 return 1;
17157 }
17158
17159
17160 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
17161 PyObject *pyobj = 0;
17162
17163 {
17164 #if wxUSE_UNICODE
17165 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17166 #else
17167 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17168 #endif
17169 }
17170 return pyobj;
17171 }
17172
17173
17174 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
17175 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
17176 return 1;
17177 }
17178
17179
17180 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
17181 PyObject *pyobj = 0;
17182
17183 {
17184 #if wxUSE_UNICODE
17185 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17186 #else
17187 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17188 #endif
17189 }
17190 return pyobj;
17191 }
17192
17193
17194 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
17195 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
17196 return 1;
17197 }
17198
17199
17200 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
17201 PyObject *pyobj = 0;
17202
17203 {
17204 #if wxUSE_UNICODE
17205 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17206 #else
17207 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17208 #endif
17209 }
17210 return pyobj;
17211 }
17212
17213
17214 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
17215 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
17216 return 1;
17217 }
17218
17219
17220 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
17221 PyObject *pyobj = 0;
17222
17223 {
17224 #if wxUSE_UNICODE
17225 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17226 #else
17227 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17228 #endif
17229 }
17230 return pyobj;
17231 }
17232
17233
17234 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
17235 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
17236 return 1;
17237 }
17238
17239
17240 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
17241 PyObject *pyobj = 0;
17242
17243 {
17244 #if wxUSE_UNICODE
17245 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17246 #else
17247 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17248 #endif
17249 }
17250 return pyobj;
17251 }
17252
17253
17254 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17255 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17256 return 1;
17257 }
17258
17259
17260 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17261 PyObject *pyobj = 0;
17262
17263 {
17264 #if wxUSE_UNICODE
17265 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17266 #else
17267 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17268 #endif
17269 }
17270 return pyobj;
17271 }
17272
17273
17274 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17275 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17276 return 1;
17277 }
17278
17279
17280 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17281 PyObject *pyobj = 0;
17282
17283 {
17284 #if wxUSE_UNICODE
17285 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17286 #else
17287 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17288 #endif
17289 }
17290 return pyobj;
17291 }
17292
17293
17294 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17295 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17296 return 1;
17297 }
17298
17299
17300 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17301 PyObject *pyobj = 0;
17302
17303 {
17304 #if wxUSE_UNICODE
17305 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17306 #else
17307 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17308 #endif
17309 }
17310 return pyobj;
17311 }
17312
17313
17314 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17315 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17316 return 1;
17317 }
17318
17319
17320 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17321 PyObject *pyobj = 0;
17322
17323 {
17324 #if wxUSE_UNICODE
17325 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17326 #else
17327 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17328 #endif
17329 }
17330 return pyobj;
17331 }
17332
17333
17334 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17335 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17336 return 1;
17337 }
17338
17339
17340 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17341 PyObject *pyobj = 0;
17342
17343 {
17344 #if wxUSE_UNICODE
17345 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17346 #else
17347 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17348 #endif
17349 }
17350 return pyobj;
17351 }
17352
17353
17354 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17355 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17356 return 1;
17357 }
17358
17359
17360 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17361 PyObject *pyobj = 0;
17362
17363 {
17364 #if wxUSE_UNICODE
17365 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17366 #else
17367 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17368 #endif
17369 }
17370 return pyobj;
17371 }
17372
17373
17374 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17375 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17376 return 1;
17377 }
17378
17379
17380 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17381 PyObject *pyobj = 0;
17382
17383 {
17384 #if wxUSE_UNICODE
17385 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17386 #else
17387 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17388 #endif
17389 }
17390 return pyobj;
17391 }
17392
17393
17394 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17395 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17396 return 1;
17397 }
17398
17399
17400 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17401 PyObject *pyobj = 0;
17402
17403 {
17404 #if wxUSE_UNICODE
17405 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17406 #else
17407 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17408 #endif
17409 }
17410 return pyobj;
17411 }
17412
17413
17414 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17415 PyObject *resultobj = 0;
17416 wxBMPHandler *result = 0 ;
17417
17418 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17419 {
17420 PyThreadState* __tstate = wxPyBeginAllowThreads();
17421 result = (wxBMPHandler *)new wxBMPHandler();
17422 wxPyEndAllowThreads(__tstate);
17423 if (PyErr_Occurred()) SWIG_fail;
17424 }
17425 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17426 return resultobj;
17427 fail:
17428 return NULL;
17429 }
17430
17431
17432 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17433 PyObject *obj;
17434 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17435 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17436 return SWIG_Py_Void();
17437 }
17438
17439 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17440 return SWIG_Python_InitShadowInstance(args);
17441 }
17442
17443 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17444 PyObject *resultobj = 0;
17445 wxICOHandler *result = 0 ;
17446
17447 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17448 {
17449 PyThreadState* __tstate = wxPyBeginAllowThreads();
17450 result = (wxICOHandler *)new wxICOHandler();
17451 wxPyEndAllowThreads(__tstate);
17452 if (PyErr_Occurred()) SWIG_fail;
17453 }
17454 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17455 return resultobj;
17456 fail:
17457 return NULL;
17458 }
17459
17460
17461 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17462 PyObject *obj;
17463 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17464 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17465 return SWIG_Py_Void();
17466 }
17467
17468 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17469 return SWIG_Python_InitShadowInstance(args);
17470 }
17471
17472 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17473 PyObject *resultobj = 0;
17474 wxCURHandler *result = 0 ;
17475
17476 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17477 {
17478 PyThreadState* __tstate = wxPyBeginAllowThreads();
17479 result = (wxCURHandler *)new wxCURHandler();
17480 wxPyEndAllowThreads(__tstate);
17481 if (PyErr_Occurred()) SWIG_fail;
17482 }
17483 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
17484 return resultobj;
17485 fail:
17486 return NULL;
17487 }
17488
17489
17490 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17491 PyObject *obj;
17492 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17493 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
17494 return SWIG_Py_Void();
17495 }
17496
17497 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17498 return SWIG_Python_InitShadowInstance(args);
17499 }
17500
17501 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17502 PyObject *resultobj = 0;
17503 wxANIHandler *result = 0 ;
17504
17505 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
17506 {
17507 PyThreadState* __tstate = wxPyBeginAllowThreads();
17508 result = (wxANIHandler *)new wxANIHandler();
17509 wxPyEndAllowThreads(__tstate);
17510 if (PyErr_Occurred()) SWIG_fail;
17511 }
17512 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
17513 return resultobj;
17514 fail:
17515 return NULL;
17516 }
17517
17518
17519 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17520 PyObject *obj;
17521 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17522 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
17523 return SWIG_Py_Void();
17524 }
17525
17526 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17527 return SWIG_Python_InitShadowInstance(args);
17528 }
17529
17530 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17531 PyObject *resultobj = 0;
17532 wxPNGHandler *result = 0 ;
17533
17534 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
17535 {
17536 PyThreadState* __tstate = wxPyBeginAllowThreads();
17537 result = (wxPNGHandler *)new wxPNGHandler();
17538 wxPyEndAllowThreads(__tstate);
17539 if (PyErr_Occurred()) SWIG_fail;
17540 }
17541 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
17542 return resultobj;
17543 fail:
17544 return NULL;
17545 }
17546
17547
17548 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17549 PyObject *obj;
17550 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17551 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
17552 return SWIG_Py_Void();
17553 }
17554
17555 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17556 return SWIG_Python_InitShadowInstance(args);
17557 }
17558
17559 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17560 PyObject *resultobj = 0;
17561 wxGIFHandler *result = 0 ;
17562
17563 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
17564 {
17565 PyThreadState* __tstate = wxPyBeginAllowThreads();
17566 result = (wxGIFHandler *)new wxGIFHandler();
17567 wxPyEndAllowThreads(__tstate);
17568 if (PyErr_Occurred()) SWIG_fail;
17569 }
17570 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
17571 return resultobj;
17572 fail:
17573 return NULL;
17574 }
17575
17576
17577 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17578 PyObject *obj;
17579 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17580 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
17581 return SWIG_Py_Void();
17582 }
17583
17584 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17585 return SWIG_Python_InitShadowInstance(args);
17586 }
17587
17588 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17589 PyObject *resultobj = 0;
17590 wxPCXHandler *result = 0 ;
17591
17592 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
17593 {
17594 PyThreadState* __tstate = wxPyBeginAllowThreads();
17595 result = (wxPCXHandler *)new wxPCXHandler();
17596 wxPyEndAllowThreads(__tstate);
17597 if (PyErr_Occurred()) SWIG_fail;
17598 }
17599 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
17600 return resultobj;
17601 fail:
17602 return NULL;
17603 }
17604
17605
17606 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17607 PyObject *obj;
17608 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17609 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
17610 return SWIG_Py_Void();
17611 }
17612
17613 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17614 return SWIG_Python_InitShadowInstance(args);
17615 }
17616
17617 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17618 PyObject *resultobj = 0;
17619 wxJPEGHandler *result = 0 ;
17620
17621 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
17622 {
17623 PyThreadState* __tstate = wxPyBeginAllowThreads();
17624 result = (wxJPEGHandler *)new wxJPEGHandler();
17625 wxPyEndAllowThreads(__tstate);
17626 if (PyErr_Occurred()) SWIG_fail;
17627 }
17628 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
17629 return resultobj;
17630 fail:
17631 return NULL;
17632 }
17633
17634
17635 SWIGINTERN PyObject *JPEGHandler_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_wxJPEGHandler, SWIG_NewClientData(obj));
17639 return SWIG_Py_Void();
17640 }
17641
17642 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17643 return SWIG_Python_InitShadowInstance(args);
17644 }
17645
17646 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17647 PyObject *resultobj = 0;
17648 wxPNMHandler *result = 0 ;
17649
17650 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
17651 {
17652 PyThreadState* __tstate = wxPyBeginAllowThreads();
17653 result = (wxPNMHandler *)new wxPNMHandler();
17654 wxPyEndAllowThreads(__tstate);
17655 if (PyErr_Occurred()) SWIG_fail;
17656 }
17657 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
17658 return resultobj;
17659 fail:
17660 return NULL;
17661 }
17662
17663
17664 SWIGINTERN PyObject *PNMHandler_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_wxPNMHandler, SWIG_NewClientData(obj));
17668 return SWIG_Py_Void();
17669 }
17670
17671 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17672 return SWIG_Python_InitShadowInstance(args);
17673 }
17674
17675 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17676 PyObject *resultobj = 0;
17677 wxXPMHandler *result = 0 ;
17678
17679 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
17680 {
17681 PyThreadState* __tstate = wxPyBeginAllowThreads();
17682 result = (wxXPMHandler *)new wxXPMHandler();
17683 wxPyEndAllowThreads(__tstate);
17684 if (PyErr_Occurred()) SWIG_fail;
17685 }
17686 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
17687 return resultobj;
17688 fail:
17689 return NULL;
17690 }
17691
17692
17693 SWIGINTERN PyObject *XPMHandler_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_wxXPMHandler, SWIG_NewClientData(obj));
17697 return SWIG_Py_Void();
17698 }
17699
17700 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17701 return SWIG_Python_InitShadowInstance(args);
17702 }
17703
17704 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17705 PyObject *resultobj = 0;
17706 wxTIFFHandler *result = 0 ;
17707
17708 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
17709 {
17710 PyThreadState* __tstate = wxPyBeginAllowThreads();
17711 result = (wxTIFFHandler *)new wxTIFFHandler();
17712 wxPyEndAllowThreads(__tstate);
17713 if (PyErr_Occurred()) SWIG_fail;
17714 }
17715 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
17716 return resultobj;
17717 fail:
17718 return NULL;
17719 }
17720
17721
17722 SWIGINTERN PyObject *TIFFHandler_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_wxTIFFHandler, SWIG_NewClientData(obj));
17726 return SWIG_Py_Void();
17727 }
17728
17729 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17730 return SWIG_Python_InitShadowInstance(args);
17731 }
17732
17733 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17734 PyObject *resultobj = 0;
17735 wxImage *arg1 = 0 ;
17736 wxImage *arg2 = 0 ;
17737 int arg3 = (int) 236 ;
17738 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
17739 bool result;
17740 void *argp1 = 0 ;
17741 int res1 = 0 ;
17742 void *argp2 = 0 ;
17743 int res2 = 0 ;
17744 int val3 ;
17745 int ecode3 = 0 ;
17746 int val4 ;
17747 int ecode4 = 0 ;
17748 PyObject * obj0 = 0 ;
17749 PyObject * obj1 = 0 ;
17750 PyObject * obj2 = 0 ;
17751 PyObject * obj3 = 0 ;
17752 char * kwnames[] = {
17753 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
17754 };
17755
17756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17757 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
17758 if (!SWIG_IsOK(res1)) {
17759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17760 }
17761 if (!argp1) {
17762 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17763 }
17764 arg1 = reinterpret_cast< wxImage * >(argp1);
17765 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
17766 if (!SWIG_IsOK(res2)) {
17767 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17768 }
17769 if (!argp2) {
17770 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17771 }
17772 arg2 = reinterpret_cast< wxImage * >(argp2);
17773 if (obj2) {
17774 ecode3 = SWIG_AsVal_int(obj2, &val3);
17775 if (!SWIG_IsOK(ecode3)) {
17776 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
17777 }
17778 arg3 = static_cast< int >(val3);
17779 }
17780 if (obj3) {
17781 ecode4 = SWIG_AsVal_int(obj3, &val4);
17782 if (!SWIG_IsOK(ecode4)) {
17783 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
17784 }
17785 arg4 = static_cast< int >(val4);
17786 }
17787 {
17788 PyThreadState* __tstate = wxPyBeginAllowThreads();
17789 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
17790 wxPyEndAllowThreads(__tstate);
17791 if (PyErr_Occurred()) SWIG_fail;
17792 }
17793 {
17794 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17795 }
17796 return resultobj;
17797 fail:
17798 return NULL;
17799 }
17800
17801
17802 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17803 PyObject *obj;
17804 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17805 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
17806 return SWIG_Py_Void();
17807 }
17808
17809 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17810 PyObject *resultobj = 0;
17811 wxEvtHandler *result = 0 ;
17812
17813 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
17814 {
17815 PyThreadState* __tstate = wxPyBeginAllowThreads();
17816 result = (wxEvtHandler *)new wxEvtHandler();
17817 wxPyEndAllowThreads(__tstate);
17818 if (PyErr_Occurred()) SWIG_fail;
17819 }
17820 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
17821 return resultobj;
17822 fail:
17823 return NULL;
17824 }
17825
17826
17827 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17828 PyObject *resultobj = 0;
17829 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17830 wxEvtHandler *result = 0 ;
17831 void *argp1 = 0 ;
17832 int res1 = 0 ;
17833 PyObject *swig_obj[1] ;
17834
17835 if (!args) SWIG_fail;
17836 swig_obj[0] = args;
17837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17838 if (!SWIG_IsOK(res1)) {
17839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17840 }
17841 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17842 {
17843 PyThreadState* __tstate = wxPyBeginAllowThreads();
17844 result = (wxEvtHandler *)(arg1)->GetNextHandler();
17845 wxPyEndAllowThreads(__tstate);
17846 if (PyErr_Occurred()) SWIG_fail;
17847 }
17848 {
17849 resultobj = wxPyMake_wxObject(result, 0);
17850 }
17851 return resultobj;
17852 fail:
17853 return NULL;
17854 }
17855
17856
17857 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17858 PyObject *resultobj = 0;
17859 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17860 wxEvtHandler *result = 0 ;
17861 void *argp1 = 0 ;
17862 int res1 = 0 ;
17863 PyObject *swig_obj[1] ;
17864
17865 if (!args) SWIG_fail;
17866 swig_obj[0] = args;
17867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17868 if (!SWIG_IsOK(res1)) {
17869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17870 }
17871 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17872 {
17873 PyThreadState* __tstate = wxPyBeginAllowThreads();
17874 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
17875 wxPyEndAllowThreads(__tstate);
17876 if (PyErr_Occurred()) SWIG_fail;
17877 }
17878 {
17879 resultobj = wxPyMake_wxObject(result, 0);
17880 }
17881 return resultobj;
17882 fail:
17883 return NULL;
17884 }
17885
17886
17887 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17888 PyObject *resultobj = 0;
17889 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17890 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17891 void *argp1 = 0 ;
17892 int res1 = 0 ;
17893 void *argp2 = 0 ;
17894 int res2 = 0 ;
17895 PyObject * obj0 = 0 ;
17896 PyObject * obj1 = 0 ;
17897 char * kwnames[] = {
17898 (char *) "self",(char *) "handler", NULL
17899 };
17900
17901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17903 if (!SWIG_IsOK(res1)) {
17904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17905 }
17906 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17907 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17908 if (!SWIG_IsOK(res2)) {
17909 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17910 }
17911 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17912 {
17913 PyThreadState* __tstate = wxPyBeginAllowThreads();
17914 (arg1)->SetNextHandler(arg2);
17915 wxPyEndAllowThreads(__tstate);
17916 if (PyErr_Occurred()) SWIG_fail;
17917 }
17918 resultobj = SWIG_Py_Void();
17919 return resultobj;
17920 fail:
17921 return NULL;
17922 }
17923
17924
17925 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17926 PyObject *resultobj = 0;
17927 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17928 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17929 void *argp1 = 0 ;
17930 int res1 = 0 ;
17931 void *argp2 = 0 ;
17932 int res2 = 0 ;
17933 PyObject * obj0 = 0 ;
17934 PyObject * obj1 = 0 ;
17935 char * kwnames[] = {
17936 (char *) "self",(char *) "handler", NULL
17937 };
17938
17939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17941 if (!SWIG_IsOK(res1)) {
17942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17943 }
17944 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17945 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17946 if (!SWIG_IsOK(res2)) {
17947 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17948 }
17949 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17950 {
17951 PyThreadState* __tstate = wxPyBeginAllowThreads();
17952 (arg1)->SetPreviousHandler(arg2);
17953 wxPyEndAllowThreads(__tstate);
17954 if (PyErr_Occurred()) SWIG_fail;
17955 }
17956 resultobj = SWIG_Py_Void();
17957 return resultobj;
17958 fail:
17959 return NULL;
17960 }
17961
17962
17963 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17964 PyObject *resultobj = 0;
17965 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17966 bool result;
17967 void *argp1 = 0 ;
17968 int res1 = 0 ;
17969 PyObject *swig_obj[1] ;
17970
17971 if (!args) SWIG_fail;
17972 swig_obj[0] = args;
17973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17974 if (!SWIG_IsOK(res1)) {
17975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17976 }
17977 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17978 {
17979 PyThreadState* __tstate = wxPyBeginAllowThreads();
17980 result = (bool)(arg1)->GetEvtHandlerEnabled();
17981 wxPyEndAllowThreads(__tstate);
17982 if (PyErr_Occurred()) SWIG_fail;
17983 }
17984 {
17985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17986 }
17987 return resultobj;
17988 fail:
17989 return NULL;
17990 }
17991
17992
17993 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17994 PyObject *resultobj = 0;
17995 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17996 bool arg2 ;
17997 void *argp1 = 0 ;
17998 int res1 = 0 ;
17999 bool val2 ;
18000 int ecode2 = 0 ;
18001 PyObject * obj0 = 0 ;
18002 PyObject * obj1 = 0 ;
18003 char * kwnames[] = {
18004 (char *) "self",(char *) "enabled", NULL
18005 };
18006
18007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
18008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18009 if (!SWIG_IsOK(res1)) {
18010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18011 }
18012 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18013 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18014 if (!SWIG_IsOK(ecode2)) {
18015 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
18016 }
18017 arg2 = static_cast< bool >(val2);
18018 {
18019 PyThreadState* __tstate = wxPyBeginAllowThreads();
18020 (arg1)->SetEvtHandlerEnabled(arg2);
18021 wxPyEndAllowThreads(__tstate);
18022 if (PyErr_Occurred()) SWIG_fail;
18023 }
18024 resultobj = SWIG_Py_Void();
18025 return resultobj;
18026 fail:
18027 return NULL;
18028 }
18029
18030
18031 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18032 PyObject *resultobj = 0;
18033 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18034 wxEvent *arg2 = 0 ;
18035 bool result;
18036 void *argp1 = 0 ;
18037 int res1 = 0 ;
18038 void *argp2 = 0 ;
18039 int res2 = 0 ;
18040 PyObject * obj0 = 0 ;
18041 PyObject * obj1 = 0 ;
18042 char * kwnames[] = {
18043 (char *) "self",(char *) "event", NULL
18044 };
18045
18046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18048 if (!SWIG_IsOK(res1)) {
18049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18050 }
18051 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18052 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
18053 if (!SWIG_IsOK(res2)) {
18054 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18055 }
18056 if (!argp2) {
18057 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18058 }
18059 arg2 = reinterpret_cast< wxEvent * >(argp2);
18060 {
18061 PyThreadState* __tstate = wxPyBeginAllowThreads();
18062 result = (bool)(arg1)->ProcessEvent(*arg2);
18063 wxPyEndAllowThreads(__tstate);
18064 if (PyErr_Occurred()) SWIG_fail;
18065 }
18066 {
18067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18068 }
18069 return resultobj;
18070 fail:
18071 return NULL;
18072 }
18073
18074
18075 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18076 PyObject *resultobj = 0;
18077 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18078 wxEvent *arg2 = 0 ;
18079 void *argp1 = 0 ;
18080 int res1 = 0 ;
18081 void *argp2 = 0 ;
18082 int res2 = 0 ;
18083 PyObject * obj0 = 0 ;
18084 PyObject * obj1 = 0 ;
18085 char * kwnames[] = {
18086 (char *) "self",(char *) "event", NULL
18087 };
18088
18089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18091 if (!SWIG_IsOK(res1)) {
18092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18093 }
18094 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18095 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
18096 if (!SWIG_IsOK(res2)) {
18097 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18098 }
18099 if (!argp2) {
18100 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18101 }
18102 arg2 = reinterpret_cast< wxEvent * >(argp2);
18103 {
18104 PyThreadState* __tstate = wxPyBeginAllowThreads();
18105 (arg1)->AddPendingEvent(*arg2);
18106 wxPyEndAllowThreads(__tstate);
18107 if (PyErr_Occurred()) SWIG_fail;
18108 }
18109 resultobj = SWIG_Py_Void();
18110 return resultobj;
18111 fail:
18112 return NULL;
18113 }
18114
18115
18116 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18117 PyObject *resultobj = 0;
18118 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18119 void *argp1 = 0 ;
18120 int res1 = 0 ;
18121 PyObject *swig_obj[1] ;
18122
18123 if (!args) SWIG_fail;
18124 swig_obj[0] = args;
18125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18126 if (!SWIG_IsOK(res1)) {
18127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18128 }
18129 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18130 {
18131 PyThreadState* __tstate = wxPyBeginAllowThreads();
18132 (arg1)->ProcessPendingEvents();
18133 wxPyEndAllowThreads(__tstate);
18134 if (PyErr_Occurred()) SWIG_fail;
18135 }
18136 resultobj = SWIG_Py_Void();
18137 return resultobj;
18138 fail:
18139 return NULL;
18140 }
18141
18142
18143 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18144 PyObject *resultobj = 0;
18145 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18146 int arg2 ;
18147 int arg3 ;
18148 int arg4 ;
18149 PyObject *arg5 = (PyObject *) 0 ;
18150 void *argp1 = 0 ;
18151 int res1 = 0 ;
18152 int val2 ;
18153 int ecode2 = 0 ;
18154 int val3 ;
18155 int ecode3 = 0 ;
18156 int val4 ;
18157 int ecode4 = 0 ;
18158 PyObject * obj0 = 0 ;
18159 PyObject * obj1 = 0 ;
18160 PyObject * obj2 = 0 ;
18161 PyObject * obj3 = 0 ;
18162 PyObject * obj4 = 0 ;
18163 char * kwnames[] = {
18164 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
18165 };
18166
18167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18169 if (!SWIG_IsOK(res1)) {
18170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18171 }
18172 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18173 ecode2 = SWIG_AsVal_int(obj1, &val2);
18174 if (!SWIG_IsOK(ecode2)) {
18175 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
18176 }
18177 arg2 = static_cast< int >(val2);
18178 ecode3 = SWIG_AsVal_int(obj2, &val3);
18179 if (!SWIG_IsOK(ecode3)) {
18180 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
18181 }
18182 arg3 = static_cast< int >(val3);
18183 ecode4 = SWIG_AsVal_int(obj3, &val4);
18184 if (!SWIG_IsOK(ecode4)) {
18185 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
18186 }
18187 arg4 = static_cast< int >(val4);
18188 arg5 = obj4;
18189 {
18190 PyThreadState* __tstate = wxPyBeginAllowThreads();
18191 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
18192 wxPyEndAllowThreads(__tstate);
18193 if (PyErr_Occurred()) SWIG_fail;
18194 }
18195 resultobj = SWIG_Py_Void();
18196 return resultobj;
18197 fail:
18198 return NULL;
18199 }
18200
18201
18202 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18203 PyObject *resultobj = 0;
18204 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18205 int arg2 ;
18206 int arg3 = (int) -1 ;
18207 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
18208 bool result;
18209 void *argp1 = 0 ;
18210 int res1 = 0 ;
18211 int val2 ;
18212 int ecode2 = 0 ;
18213 int val3 ;
18214 int ecode3 = 0 ;
18215 int val4 ;
18216 int ecode4 = 0 ;
18217 PyObject * obj0 = 0 ;
18218 PyObject * obj1 = 0 ;
18219 PyObject * obj2 = 0 ;
18220 PyObject * obj3 = 0 ;
18221 char * kwnames[] = {
18222 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
18223 };
18224
18225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18227 if (!SWIG_IsOK(res1)) {
18228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18229 }
18230 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18231 ecode2 = SWIG_AsVal_int(obj1, &val2);
18232 if (!SWIG_IsOK(ecode2)) {
18233 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
18234 }
18235 arg2 = static_cast< int >(val2);
18236 if (obj2) {
18237 ecode3 = SWIG_AsVal_int(obj2, &val3);
18238 if (!SWIG_IsOK(ecode3)) {
18239 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
18240 }
18241 arg3 = static_cast< int >(val3);
18242 }
18243 if (obj3) {
18244 ecode4 = SWIG_AsVal_int(obj3, &val4);
18245 if (!SWIG_IsOK(ecode4)) {
18246 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
18247 }
18248 arg4 = static_cast< wxEventType >(val4);
18249 }
18250 {
18251 PyThreadState* __tstate = wxPyBeginAllowThreads();
18252 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18253 wxPyEndAllowThreads(__tstate);
18254 if (PyErr_Occurred()) SWIG_fail;
18255 }
18256 {
18257 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18258 }
18259 return resultobj;
18260 fail:
18261 return NULL;
18262 }
18263
18264
18265 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18266 PyObject *resultobj = 0;
18267 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18268 PyObject *arg2 = (PyObject *) 0 ;
18269 bool arg3 = (bool) true ;
18270 void *argp1 = 0 ;
18271 int res1 = 0 ;
18272 bool val3 ;
18273 int ecode3 = 0 ;
18274 PyObject * obj0 = 0 ;
18275 PyObject * obj1 = 0 ;
18276 PyObject * obj2 = 0 ;
18277 char * kwnames[] = {
18278 (char *) "self",(char *) "_self",(char *) "incref", NULL
18279 };
18280
18281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18283 if (!SWIG_IsOK(res1)) {
18284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18285 }
18286 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18287 arg2 = obj1;
18288 if (obj2) {
18289 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18290 if (!SWIG_IsOK(ecode3)) {
18291 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18292 }
18293 arg3 = static_cast< bool >(val3);
18294 }
18295 {
18296 PyThreadState* __tstate = wxPyBeginAllowThreads();
18297 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18298 wxPyEndAllowThreads(__tstate);
18299 if (PyErr_Occurred()) SWIG_fail;
18300 }
18301 resultobj = SWIG_Py_Void();
18302 return resultobj;
18303 fail:
18304 return NULL;
18305 }
18306
18307
18308 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18309 PyObject *obj;
18310 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18311 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18312 return SWIG_Py_Void();
18313 }
18314
18315 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18316 return SWIG_Python_InitShadowInstance(args);
18317 }
18318
18319 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18320 PyObject *resultobj = 0;
18321 wxEventType result;
18322
18323 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18324 {
18325 PyThreadState* __tstate = wxPyBeginAllowThreads();
18326 result = (wxEventType)wxNewEventType();
18327 wxPyEndAllowThreads(__tstate);
18328 if (PyErr_Occurred()) SWIG_fail;
18329 }
18330 resultobj = SWIG_From_int(static_cast< int >(result));
18331 return resultobj;
18332 fail:
18333 return NULL;
18334 }
18335
18336
18337 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18338 PyObject *resultobj = 0;
18339 wxEvent *arg1 = (wxEvent *) 0 ;
18340 void *argp1 = 0 ;
18341 int res1 = 0 ;
18342 PyObject *swig_obj[1] ;
18343
18344 if (!args) SWIG_fail;
18345 swig_obj[0] = args;
18346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18347 if (!SWIG_IsOK(res1)) {
18348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18349 }
18350 arg1 = reinterpret_cast< wxEvent * >(argp1);
18351 {
18352 PyThreadState* __tstate = wxPyBeginAllowThreads();
18353 delete arg1;
18354
18355 wxPyEndAllowThreads(__tstate);
18356 if (PyErr_Occurred()) SWIG_fail;
18357 }
18358 resultobj = SWIG_Py_Void();
18359 return resultobj;
18360 fail:
18361 return NULL;
18362 }
18363
18364
18365 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18366 PyObject *resultobj = 0;
18367 wxEvent *arg1 = (wxEvent *) 0 ;
18368 wxEventType arg2 ;
18369 void *argp1 = 0 ;
18370 int res1 = 0 ;
18371 int val2 ;
18372 int ecode2 = 0 ;
18373 PyObject * obj0 = 0 ;
18374 PyObject * obj1 = 0 ;
18375 char * kwnames[] = {
18376 (char *) "self",(char *) "typ", NULL
18377 };
18378
18379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18381 if (!SWIG_IsOK(res1)) {
18382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18383 }
18384 arg1 = reinterpret_cast< wxEvent * >(argp1);
18385 ecode2 = SWIG_AsVal_int(obj1, &val2);
18386 if (!SWIG_IsOK(ecode2)) {
18387 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18388 }
18389 arg2 = static_cast< wxEventType >(val2);
18390 {
18391 PyThreadState* __tstate = wxPyBeginAllowThreads();
18392 (arg1)->SetEventType(arg2);
18393 wxPyEndAllowThreads(__tstate);
18394 if (PyErr_Occurred()) SWIG_fail;
18395 }
18396 resultobj = SWIG_Py_Void();
18397 return resultobj;
18398 fail:
18399 return NULL;
18400 }
18401
18402
18403 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18404 PyObject *resultobj = 0;
18405 wxEvent *arg1 = (wxEvent *) 0 ;
18406 wxEventType result;
18407 void *argp1 = 0 ;
18408 int res1 = 0 ;
18409 PyObject *swig_obj[1] ;
18410
18411 if (!args) SWIG_fail;
18412 swig_obj[0] = args;
18413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18414 if (!SWIG_IsOK(res1)) {
18415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18416 }
18417 arg1 = reinterpret_cast< wxEvent * >(argp1);
18418 {
18419 PyThreadState* __tstate = wxPyBeginAllowThreads();
18420 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18421 wxPyEndAllowThreads(__tstate);
18422 if (PyErr_Occurred()) SWIG_fail;
18423 }
18424 resultobj = SWIG_From_int(static_cast< int >(result));
18425 return resultobj;
18426 fail:
18427 return NULL;
18428 }
18429
18430
18431 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18432 PyObject *resultobj = 0;
18433 wxEvent *arg1 = (wxEvent *) 0 ;
18434 wxObject *result = 0 ;
18435 void *argp1 = 0 ;
18436 int res1 = 0 ;
18437 PyObject *swig_obj[1] ;
18438
18439 if (!args) SWIG_fail;
18440 swig_obj[0] = args;
18441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18442 if (!SWIG_IsOK(res1)) {
18443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18444 }
18445 arg1 = reinterpret_cast< wxEvent * >(argp1);
18446 {
18447 PyThreadState* __tstate = wxPyBeginAllowThreads();
18448 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18449 wxPyEndAllowThreads(__tstate);
18450 if (PyErr_Occurred()) SWIG_fail;
18451 }
18452 {
18453 resultobj = wxPyMake_wxObject(result, (bool)0);
18454 }
18455 return resultobj;
18456 fail:
18457 return NULL;
18458 }
18459
18460
18461 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18462 PyObject *resultobj = 0;
18463 wxEvent *arg1 = (wxEvent *) 0 ;
18464 wxObject *arg2 = (wxObject *) 0 ;
18465 void *argp1 = 0 ;
18466 int res1 = 0 ;
18467 void *argp2 = 0 ;
18468 int res2 = 0 ;
18469 PyObject * obj0 = 0 ;
18470 PyObject * obj1 = 0 ;
18471 char * kwnames[] = {
18472 (char *) "self",(char *) "obj", NULL
18473 };
18474
18475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18477 if (!SWIG_IsOK(res1)) {
18478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18479 }
18480 arg1 = reinterpret_cast< wxEvent * >(argp1);
18481 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18482 if (!SWIG_IsOK(res2)) {
18483 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
18484 }
18485 arg2 = reinterpret_cast< wxObject * >(argp2);
18486 {
18487 PyThreadState* __tstate = wxPyBeginAllowThreads();
18488 (arg1)->SetEventObject(arg2);
18489 wxPyEndAllowThreads(__tstate);
18490 if (PyErr_Occurred()) SWIG_fail;
18491 }
18492 resultobj = SWIG_Py_Void();
18493 return resultobj;
18494 fail:
18495 return NULL;
18496 }
18497
18498
18499 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18500 PyObject *resultobj = 0;
18501 wxEvent *arg1 = (wxEvent *) 0 ;
18502 long result;
18503 void *argp1 = 0 ;
18504 int res1 = 0 ;
18505 PyObject *swig_obj[1] ;
18506
18507 if (!args) SWIG_fail;
18508 swig_obj[0] = args;
18509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18510 if (!SWIG_IsOK(res1)) {
18511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
18512 }
18513 arg1 = reinterpret_cast< wxEvent * >(argp1);
18514 {
18515 PyThreadState* __tstate = wxPyBeginAllowThreads();
18516 result = (long)((wxEvent const *)arg1)->GetTimestamp();
18517 wxPyEndAllowThreads(__tstate);
18518 if (PyErr_Occurred()) SWIG_fail;
18519 }
18520 resultobj = SWIG_From_long(static_cast< long >(result));
18521 return resultobj;
18522 fail:
18523 return NULL;
18524 }
18525
18526
18527 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18528 PyObject *resultobj = 0;
18529 wxEvent *arg1 = (wxEvent *) 0 ;
18530 long arg2 = (long) 0 ;
18531 void *argp1 = 0 ;
18532 int res1 = 0 ;
18533 long val2 ;
18534 int ecode2 = 0 ;
18535 PyObject * obj0 = 0 ;
18536 PyObject * obj1 = 0 ;
18537 char * kwnames[] = {
18538 (char *) "self",(char *) "ts", NULL
18539 };
18540
18541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
18542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18543 if (!SWIG_IsOK(res1)) {
18544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
18545 }
18546 arg1 = reinterpret_cast< wxEvent * >(argp1);
18547 if (obj1) {
18548 ecode2 = SWIG_AsVal_long(obj1, &val2);
18549 if (!SWIG_IsOK(ecode2)) {
18550 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
18551 }
18552 arg2 = static_cast< long >(val2);
18553 }
18554 {
18555 PyThreadState* __tstate = wxPyBeginAllowThreads();
18556 (arg1)->SetTimestamp(arg2);
18557 wxPyEndAllowThreads(__tstate);
18558 if (PyErr_Occurred()) SWIG_fail;
18559 }
18560 resultobj = SWIG_Py_Void();
18561 return resultobj;
18562 fail:
18563 return NULL;
18564 }
18565
18566
18567 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18568 PyObject *resultobj = 0;
18569 wxEvent *arg1 = (wxEvent *) 0 ;
18570 int result;
18571 void *argp1 = 0 ;
18572 int res1 = 0 ;
18573 PyObject *swig_obj[1] ;
18574
18575 if (!args) SWIG_fail;
18576 swig_obj[0] = args;
18577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18578 if (!SWIG_IsOK(res1)) {
18579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
18580 }
18581 arg1 = reinterpret_cast< wxEvent * >(argp1);
18582 {
18583 PyThreadState* __tstate = wxPyBeginAllowThreads();
18584 result = (int)((wxEvent const *)arg1)->GetId();
18585 wxPyEndAllowThreads(__tstate);
18586 if (PyErr_Occurred()) SWIG_fail;
18587 }
18588 resultobj = SWIG_From_int(static_cast< int >(result));
18589 return resultobj;
18590 fail:
18591 return NULL;
18592 }
18593
18594
18595 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18596 PyObject *resultobj = 0;
18597 wxEvent *arg1 = (wxEvent *) 0 ;
18598 int arg2 ;
18599 void *argp1 = 0 ;
18600 int res1 = 0 ;
18601 int val2 ;
18602 int ecode2 = 0 ;
18603 PyObject * obj0 = 0 ;
18604 PyObject * obj1 = 0 ;
18605 char * kwnames[] = {
18606 (char *) "self",(char *) "Id", NULL
18607 };
18608
18609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
18610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18611 if (!SWIG_IsOK(res1)) {
18612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
18613 }
18614 arg1 = reinterpret_cast< wxEvent * >(argp1);
18615 ecode2 = SWIG_AsVal_int(obj1, &val2);
18616 if (!SWIG_IsOK(ecode2)) {
18617 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
18618 }
18619 arg2 = static_cast< int >(val2);
18620 {
18621 PyThreadState* __tstate = wxPyBeginAllowThreads();
18622 (arg1)->SetId(arg2);
18623 wxPyEndAllowThreads(__tstate);
18624 if (PyErr_Occurred()) SWIG_fail;
18625 }
18626 resultobj = SWIG_Py_Void();
18627 return resultobj;
18628 fail:
18629 return NULL;
18630 }
18631
18632
18633 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18634 PyObject *resultobj = 0;
18635 wxEvent *arg1 = (wxEvent *) 0 ;
18636 bool result;
18637 void *argp1 = 0 ;
18638 int res1 = 0 ;
18639 PyObject *swig_obj[1] ;
18640
18641 if (!args) SWIG_fail;
18642 swig_obj[0] = args;
18643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18644 if (!SWIG_IsOK(res1)) {
18645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
18646 }
18647 arg1 = reinterpret_cast< wxEvent * >(argp1);
18648 {
18649 PyThreadState* __tstate = wxPyBeginAllowThreads();
18650 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
18651 wxPyEndAllowThreads(__tstate);
18652 if (PyErr_Occurred()) SWIG_fail;
18653 }
18654 {
18655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18656 }
18657 return resultobj;
18658 fail:
18659 return NULL;
18660 }
18661
18662
18663 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18664 PyObject *resultobj = 0;
18665 wxEvent *arg1 = (wxEvent *) 0 ;
18666 bool arg2 = (bool) true ;
18667 void *argp1 = 0 ;
18668 int res1 = 0 ;
18669 bool val2 ;
18670 int ecode2 = 0 ;
18671 PyObject * obj0 = 0 ;
18672 PyObject * obj1 = 0 ;
18673 char * kwnames[] = {
18674 (char *) "self",(char *) "skip", NULL
18675 };
18676
18677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
18678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18679 if (!SWIG_IsOK(res1)) {
18680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
18681 }
18682 arg1 = reinterpret_cast< wxEvent * >(argp1);
18683 if (obj1) {
18684 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18685 if (!SWIG_IsOK(ecode2)) {
18686 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
18687 }
18688 arg2 = static_cast< bool >(val2);
18689 }
18690 {
18691 PyThreadState* __tstate = wxPyBeginAllowThreads();
18692 (arg1)->Skip(arg2);
18693 wxPyEndAllowThreads(__tstate);
18694 if (PyErr_Occurred()) SWIG_fail;
18695 }
18696 resultobj = SWIG_Py_Void();
18697 return resultobj;
18698 fail:
18699 return NULL;
18700 }
18701
18702
18703 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18704 PyObject *resultobj = 0;
18705 wxEvent *arg1 = (wxEvent *) 0 ;
18706 bool result;
18707 void *argp1 = 0 ;
18708 int res1 = 0 ;
18709 PyObject *swig_obj[1] ;
18710
18711 if (!args) SWIG_fail;
18712 swig_obj[0] = args;
18713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18714 if (!SWIG_IsOK(res1)) {
18715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
18716 }
18717 arg1 = reinterpret_cast< wxEvent * >(argp1);
18718 {
18719 PyThreadState* __tstate = wxPyBeginAllowThreads();
18720 result = (bool)((wxEvent const *)arg1)->GetSkipped();
18721 wxPyEndAllowThreads(__tstate);
18722 if (PyErr_Occurred()) SWIG_fail;
18723 }
18724 {
18725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18726 }
18727 return resultobj;
18728 fail:
18729 return NULL;
18730 }
18731
18732
18733 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18734 PyObject *resultobj = 0;
18735 wxEvent *arg1 = (wxEvent *) 0 ;
18736 bool result;
18737 void *argp1 = 0 ;
18738 int res1 = 0 ;
18739 PyObject *swig_obj[1] ;
18740
18741 if (!args) SWIG_fail;
18742 swig_obj[0] = args;
18743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18744 if (!SWIG_IsOK(res1)) {
18745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
18746 }
18747 arg1 = reinterpret_cast< wxEvent * >(argp1);
18748 {
18749 PyThreadState* __tstate = wxPyBeginAllowThreads();
18750 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
18751 wxPyEndAllowThreads(__tstate);
18752 if (PyErr_Occurred()) SWIG_fail;
18753 }
18754 {
18755 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18756 }
18757 return resultobj;
18758 fail:
18759 return NULL;
18760 }
18761
18762
18763 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18764 PyObject *resultobj = 0;
18765 wxEvent *arg1 = (wxEvent *) 0 ;
18766 int result;
18767 void *argp1 = 0 ;
18768 int res1 = 0 ;
18769 PyObject *swig_obj[1] ;
18770
18771 if (!args) SWIG_fail;
18772 swig_obj[0] = args;
18773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18774 if (!SWIG_IsOK(res1)) {
18775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18776 }
18777 arg1 = reinterpret_cast< wxEvent * >(argp1);
18778 {
18779 PyThreadState* __tstate = wxPyBeginAllowThreads();
18780 result = (int)(arg1)->StopPropagation();
18781 wxPyEndAllowThreads(__tstate);
18782 if (PyErr_Occurred()) SWIG_fail;
18783 }
18784 resultobj = SWIG_From_int(static_cast< int >(result));
18785 return resultobj;
18786 fail:
18787 return NULL;
18788 }
18789
18790
18791 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18792 PyObject *resultobj = 0;
18793 wxEvent *arg1 = (wxEvent *) 0 ;
18794 int arg2 ;
18795 void *argp1 = 0 ;
18796 int res1 = 0 ;
18797 int val2 ;
18798 int ecode2 = 0 ;
18799 PyObject * obj0 = 0 ;
18800 PyObject * obj1 = 0 ;
18801 char * kwnames[] = {
18802 (char *) "self",(char *) "propagationLevel", NULL
18803 };
18804
18805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
18806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18807 if (!SWIG_IsOK(res1)) {
18808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18809 }
18810 arg1 = reinterpret_cast< wxEvent * >(argp1);
18811 ecode2 = SWIG_AsVal_int(obj1, &val2);
18812 if (!SWIG_IsOK(ecode2)) {
18813 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
18814 }
18815 arg2 = static_cast< int >(val2);
18816 {
18817 PyThreadState* __tstate = wxPyBeginAllowThreads();
18818 (arg1)->ResumePropagation(arg2);
18819 wxPyEndAllowThreads(__tstate);
18820 if (PyErr_Occurred()) SWIG_fail;
18821 }
18822 resultobj = SWIG_Py_Void();
18823 return resultobj;
18824 fail:
18825 return NULL;
18826 }
18827
18828
18829 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18830 PyObject *resultobj = 0;
18831 wxEvent *arg1 = (wxEvent *) 0 ;
18832 wxEvent *result = 0 ;
18833 void *argp1 = 0 ;
18834 int res1 = 0 ;
18835 PyObject *swig_obj[1] ;
18836
18837 if (!args) SWIG_fail;
18838 swig_obj[0] = args;
18839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18840 if (!SWIG_IsOK(res1)) {
18841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
18842 }
18843 arg1 = reinterpret_cast< wxEvent * >(argp1);
18844 {
18845 PyThreadState* __tstate = wxPyBeginAllowThreads();
18846 result = (wxEvent *)(arg1)->Clone();
18847 wxPyEndAllowThreads(__tstate);
18848 if (PyErr_Occurred()) SWIG_fail;
18849 }
18850 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
18851 return resultobj;
18852 fail:
18853 return NULL;
18854 }
18855
18856
18857 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18858 PyObject *obj;
18859 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18860 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
18861 return SWIG_Py_Void();
18862 }
18863
18864 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18865 PyObject *resultobj = 0;
18866 wxEvent *arg1 = 0 ;
18867 wxPropagationDisabler *result = 0 ;
18868 void *argp1 = 0 ;
18869 int res1 = 0 ;
18870 PyObject * obj0 = 0 ;
18871 char * kwnames[] = {
18872 (char *) "event", NULL
18873 };
18874
18875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
18876 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18877 if (!SWIG_IsOK(res1)) {
18878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18879 }
18880 if (!argp1) {
18881 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18882 }
18883 arg1 = reinterpret_cast< wxEvent * >(argp1);
18884 {
18885 PyThreadState* __tstate = wxPyBeginAllowThreads();
18886 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
18887 wxPyEndAllowThreads(__tstate);
18888 if (PyErr_Occurred()) SWIG_fail;
18889 }
18890 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
18891 return resultobj;
18892 fail:
18893 return NULL;
18894 }
18895
18896
18897 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18898 PyObject *resultobj = 0;
18899 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
18900 void *argp1 = 0 ;
18901 int res1 = 0 ;
18902 PyObject *swig_obj[1] ;
18903
18904 if (!args) SWIG_fail;
18905 swig_obj[0] = args;
18906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
18907 if (!SWIG_IsOK(res1)) {
18908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
18909 }
18910 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
18911 {
18912 PyThreadState* __tstate = wxPyBeginAllowThreads();
18913 delete arg1;
18914
18915 wxPyEndAllowThreads(__tstate);
18916 if (PyErr_Occurred()) SWIG_fail;
18917 }
18918 resultobj = SWIG_Py_Void();
18919 return resultobj;
18920 fail:
18921 return NULL;
18922 }
18923
18924
18925 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18926 PyObject *obj;
18927 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18928 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
18929 return SWIG_Py_Void();
18930 }
18931
18932 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18933 return SWIG_Python_InitShadowInstance(args);
18934 }
18935
18936 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18937 PyObject *resultobj = 0;
18938 wxEvent *arg1 = 0 ;
18939 wxPropagateOnce *result = 0 ;
18940 void *argp1 = 0 ;
18941 int res1 = 0 ;
18942 PyObject * obj0 = 0 ;
18943 char * kwnames[] = {
18944 (char *) "event", NULL
18945 };
18946
18947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
18948 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18949 if (!SWIG_IsOK(res1)) {
18950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18951 }
18952 if (!argp1) {
18953 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18954 }
18955 arg1 = reinterpret_cast< wxEvent * >(argp1);
18956 {
18957 PyThreadState* __tstate = wxPyBeginAllowThreads();
18958 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
18959 wxPyEndAllowThreads(__tstate);
18960 if (PyErr_Occurred()) SWIG_fail;
18961 }
18962 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
18963 return resultobj;
18964 fail:
18965 return NULL;
18966 }
18967
18968
18969 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18970 PyObject *resultobj = 0;
18971 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
18972 void *argp1 = 0 ;
18973 int res1 = 0 ;
18974 PyObject *swig_obj[1] ;
18975
18976 if (!args) SWIG_fail;
18977 swig_obj[0] = args;
18978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
18979 if (!SWIG_IsOK(res1)) {
18980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
18981 }
18982 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
18983 {
18984 PyThreadState* __tstate = wxPyBeginAllowThreads();
18985 delete arg1;
18986
18987 wxPyEndAllowThreads(__tstate);
18988 if (PyErr_Occurred()) SWIG_fail;
18989 }
18990 resultobj = SWIG_Py_Void();
18991 return resultobj;
18992 fail:
18993 return NULL;
18994 }
18995
18996
18997 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18998 PyObject *obj;
18999 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19000 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
19001 return SWIG_Py_Void();
19002 }
19003
19004 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19005 return SWIG_Python_InitShadowInstance(args);
19006 }
19007
19008 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19009 PyObject *resultobj = 0;
19010 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19011 int arg2 = (int) 0 ;
19012 wxCommandEvent *result = 0 ;
19013 int val1 ;
19014 int ecode1 = 0 ;
19015 int val2 ;
19016 int ecode2 = 0 ;
19017 PyObject * obj0 = 0 ;
19018 PyObject * obj1 = 0 ;
19019 char * kwnames[] = {
19020 (char *) "commandType",(char *) "winid", NULL
19021 };
19022
19023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19024 if (obj0) {
19025 ecode1 = SWIG_AsVal_int(obj0, &val1);
19026 if (!SWIG_IsOK(ecode1)) {
19027 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19028 }
19029 arg1 = static_cast< wxEventType >(val1);
19030 }
19031 if (obj1) {
19032 ecode2 = SWIG_AsVal_int(obj1, &val2);
19033 if (!SWIG_IsOK(ecode2)) {
19034 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
19035 }
19036 arg2 = static_cast< int >(val2);
19037 }
19038 {
19039 PyThreadState* __tstate = wxPyBeginAllowThreads();
19040 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
19041 wxPyEndAllowThreads(__tstate);
19042 if (PyErr_Occurred()) SWIG_fail;
19043 }
19044 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
19045 return resultobj;
19046 fail:
19047 return NULL;
19048 }
19049
19050
19051 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19052 PyObject *resultobj = 0;
19053 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19054 int result;
19055 void *argp1 = 0 ;
19056 int res1 = 0 ;
19057 PyObject *swig_obj[1] ;
19058
19059 if (!args) SWIG_fail;
19060 swig_obj[0] = args;
19061 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19062 if (!SWIG_IsOK(res1)) {
19063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19064 }
19065 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19066 {
19067 PyThreadState* __tstate = wxPyBeginAllowThreads();
19068 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
19069 wxPyEndAllowThreads(__tstate);
19070 if (PyErr_Occurred()) SWIG_fail;
19071 }
19072 resultobj = SWIG_From_int(static_cast< int >(result));
19073 return resultobj;
19074 fail:
19075 return NULL;
19076 }
19077
19078
19079 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19080 PyObject *resultobj = 0;
19081 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19082 wxString *arg2 = 0 ;
19083 void *argp1 = 0 ;
19084 int res1 = 0 ;
19085 bool temp2 = false ;
19086 PyObject * obj0 = 0 ;
19087 PyObject * obj1 = 0 ;
19088 char * kwnames[] = {
19089 (char *) "self",(char *) "s", NULL
19090 };
19091
19092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
19093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19094 if (!SWIG_IsOK(res1)) {
19095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19096 }
19097 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19098 {
19099 arg2 = wxString_in_helper(obj1);
19100 if (arg2 == NULL) SWIG_fail;
19101 temp2 = true;
19102 }
19103 {
19104 PyThreadState* __tstate = wxPyBeginAllowThreads();
19105 (arg1)->SetString((wxString const &)*arg2);
19106 wxPyEndAllowThreads(__tstate);
19107 if (PyErr_Occurred()) SWIG_fail;
19108 }
19109 resultobj = SWIG_Py_Void();
19110 {
19111 if (temp2)
19112 delete arg2;
19113 }
19114 return resultobj;
19115 fail:
19116 {
19117 if (temp2)
19118 delete arg2;
19119 }
19120 return NULL;
19121 }
19122
19123
19124 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19125 PyObject *resultobj = 0;
19126 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19127 wxString result;
19128 void *argp1 = 0 ;
19129 int res1 = 0 ;
19130 PyObject *swig_obj[1] ;
19131
19132 if (!args) SWIG_fail;
19133 swig_obj[0] = args;
19134 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19135 if (!SWIG_IsOK(res1)) {
19136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19137 }
19138 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19139 {
19140 PyThreadState* __tstate = wxPyBeginAllowThreads();
19141 result = ((wxCommandEvent const *)arg1)->GetString();
19142 wxPyEndAllowThreads(__tstate);
19143 if (PyErr_Occurred()) SWIG_fail;
19144 }
19145 {
19146 #if wxUSE_UNICODE
19147 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19148 #else
19149 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19150 #endif
19151 }
19152 return resultobj;
19153 fail:
19154 return NULL;
19155 }
19156
19157
19158 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19159 PyObject *resultobj = 0;
19160 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19161 bool result;
19162 void *argp1 = 0 ;
19163 int res1 = 0 ;
19164 PyObject *swig_obj[1] ;
19165
19166 if (!args) SWIG_fail;
19167 swig_obj[0] = args;
19168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19169 if (!SWIG_IsOK(res1)) {
19170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19171 }
19172 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19173 {
19174 PyThreadState* __tstate = wxPyBeginAllowThreads();
19175 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
19176 wxPyEndAllowThreads(__tstate);
19177 if (PyErr_Occurred()) SWIG_fail;
19178 }
19179 {
19180 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19181 }
19182 return resultobj;
19183 fail:
19184 return NULL;
19185 }
19186
19187
19188 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19189 PyObject *resultobj = 0;
19190 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19191 bool result;
19192 void *argp1 = 0 ;
19193 int res1 = 0 ;
19194 PyObject *swig_obj[1] ;
19195
19196 if (!args) SWIG_fail;
19197 swig_obj[0] = args;
19198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19199 if (!SWIG_IsOK(res1)) {
19200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19201 }
19202 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19203 {
19204 PyThreadState* __tstate = wxPyBeginAllowThreads();
19205 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
19206 wxPyEndAllowThreads(__tstate);
19207 if (PyErr_Occurred()) SWIG_fail;
19208 }
19209 {
19210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19211 }
19212 return resultobj;
19213 fail:
19214 return NULL;
19215 }
19216
19217
19218 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19219 PyObject *resultobj = 0;
19220 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19221 long arg2 ;
19222 void *argp1 = 0 ;
19223 int res1 = 0 ;
19224 long val2 ;
19225 int ecode2 = 0 ;
19226 PyObject * obj0 = 0 ;
19227 PyObject * obj1 = 0 ;
19228 char * kwnames[] = {
19229 (char *) "self",(char *) "extraLong", NULL
19230 };
19231
19232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
19233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19234 if (!SWIG_IsOK(res1)) {
19235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19236 }
19237 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19238 ecode2 = SWIG_AsVal_long(obj1, &val2);
19239 if (!SWIG_IsOK(ecode2)) {
19240 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
19241 }
19242 arg2 = static_cast< long >(val2);
19243 {
19244 PyThreadState* __tstate = wxPyBeginAllowThreads();
19245 (arg1)->SetExtraLong(arg2);
19246 wxPyEndAllowThreads(__tstate);
19247 if (PyErr_Occurred()) SWIG_fail;
19248 }
19249 resultobj = SWIG_Py_Void();
19250 return resultobj;
19251 fail:
19252 return NULL;
19253 }
19254
19255
19256 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19257 PyObject *resultobj = 0;
19258 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19259 long result;
19260 void *argp1 = 0 ;
19261 int res1 = 0 ;
19262 PyObject *swig_obj[1] ;
19263
19264 if (!args) SWIG_fail;
19265 swig_obj[0] = args;
19266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19267 if (!SWIG_IsOK(res1)) {
19268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19269 }
19270 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19271 {
19272 PyThreadState* __tstate = wxPyBeginAllowThreads();
19273 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19274 wxPyEndAllowThreads(__tstate);
19275 if (PyErr_Occurred()) SWIG_fail;
19276 }
19277 resultobj = SWIG_From_long(static_cast< long >(result));
19278 return resultobj;
19279 fail:
19280 return NULL;
19281 }
19282
19283
19284 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19285 PyObject *resultobj = 0;
19286 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19287 int arg2 ;
19288 void *argp1 = 0 ;
19289 int res1 = 0 ;
19290 int val2 ;
19291 int ecode2 = 0 ;
19292 PyObject * obj0 = 0 ;
19293 PyObject * obj1 = 0 ;
19294 char * kwnames[] = {
19295 (char *) "self",(char *) "i", NULL
19296 };
19297
19298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19300 if (!SWIG_IsOK(res1)) {
19301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19302 }
19303 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19304 ecode2 = SWIG_AsVal_int(obj1, &val2);
19305 if (!SWIG_IsOK(ecode2)) {
19306 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19307 }
19308 arg2 = static_cast< int >(val2);
19309 {
19310 PyThreadState* __tstate = wxPyBeginAllowThreads();
19311 (arg1)->SetInt(arg2);
19312 wxPyEndAllowThreads(__tstate);
19313 if (PyErr_Occurred()) SWIG_fail;
19314 }
19315 resultobj = SWIG_Py_Void();
19316 return resultobj;
19317 fail:
19318 return NULL;
19319 }
19320
19321
19322 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19323 PyObject *resultobj = 0;
19324 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19325 int result;
19326 void *argp1 = 0 ;
19327 int res1 = 0 ;
19328 PyObject *swig_obj[1] ;
19329
19330 if (!args) SWIG_fail;
19331 swig_obj[0] = args;
19332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19333 if (!SWIG_IsOK(res1)) {
19334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19335 }
19336 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19337 {
19338 PyThreadState* __tstate = wxPyBeginAllowThreads();
19339 result = (int)((wxCommandEvent const *)arg1)->GetInt();
19340 wxPyEndAllowThreads(__tstate);
19341 if (PyErr_Occurred()) SWIG_fail;
19342 }
19343 resultobj = SWIG_From_int(static_cast< int >(result));
19344 return resultobj;
19345 fail:
19346 return NULL;
19347 }
19348
19349
19350 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19351 PyObject *resultobj = 0;
19352 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19353 PyObject *result = 0 ;
19354 void *argp1 = 0 ;
19355 int res1 = 0 ;
19356 PyObject *swig_obj[1] ;
19357
19358 if (!args) SWIG_fail;
19359 swig_obj[0] = args;
19360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19361 if (!SWIG_IsOK(res1)) {
19362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19363 }
19364 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19365 {
19366 PyThreadState* __tstate = wxPyBeginAllowThreads();
19367 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19368 wxPyEndAllowThreads(__tstate);
19369 if (PyErr_Occurred()) SWIG_fail;
19370 }
19371 resultobj = result;
19372 return resultobj;
19373 fail:
19374 return NULL;
19375 }
19376
19377
19378 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19379 PyObject *resultobj = 0;
19380 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19381 PyObject *arg2 = (PyObject *) 0 ;
19382 void *argp1 = 0 ;
19383 int res1 = 0 ;
19384 PyObject * obj0 = 0 ;
19385 PyObject * obj1 = 0 ;
19386 char * kwnames[] = {
19387 (char *) "self",(char *) "clientData", NULL
19388 };
19389
19390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19392 if (!SWIG_IsOK(res1)) {
19393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19394 }
19395 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19396 arg2 = obj1;
19397 {
19398 PyThreadState* __tstate = wxPyBeginAllowThreads();
19399 wxCommandEvent_SetClientData(arg1,arg2);
19400 wxPyEndAllowThreads(__tstate);
19401 if (PyErr_Occurred()) SWIG_fail;
19402 }
19403 resultobj = SWIG_Py_Void();
19404 return resultobj;
19405 fail:
19406 return NULL;
19407 }
19408
19409
19410 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19411 PyObject *resultobj = 0;
19412 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19413 wxEvent *result = 0 ;
19414 void *argp1 = 0 ;
19415 int res1 = 0 ;
19416 PyObject *swig_obj[1] ;
19417
19418 if (!args) SWIG_fail;
19419 swig_obj[0] = args;
19420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19421 if (!SWIG_IsOK(res1)) {
19422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19423 }
19424 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19425 {
19426 PyThreadState* __tstate = wxPyBeginAllowThreads();
19427 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19428 wxPyEndAllowThreads(__tstate);
19429 if (PyErr_Occurred()) SWIG_fail;
19430 }
19431 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19432 return resultobj;
19433 fail:
19434 return NULL;
19435 }
19436
19437
19438 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19439 PyObject *obj;
19440 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19441 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19442 return SWIG_Py_Void();
19443 }
19444
19445 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19446 return SWIG_Python_InitShadowInstance(args);
19447 }
19448
19449 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19450 PyObject *resultobj = 0;
19451 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19452 int arg2 = (int) 0 ;
19453 wxNotifyEvent *result = 0 ;
19454 int val1 ;
19455 int ecode1 = 0 ;
19456 int val2 ;
19457 int ecode2 = 0 ;
19458 PyObject * obj0 = 0 ;
19459 PyObject * obj1 = 0 ;
19460 char * kwnames[] = {
19461 (char *) "commandType",(char *) "winid", NULL
19462 };
19463
19464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19465 if (obj0) {
19466 ecode1 = SWIG_AsVal_int(obj0, &val1);
19467 if (!SWIG_IsOK(ecode1)) {
19468 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19469 }
19470 arg1 = static_cast< wxEventType >(val1);
19471 }
19472 if (obj1) {
19473 ecode2 = SWIG_AsVal_int(obj1, &val2);
19474 if (!SWIG_IsOK(ecode2)) {
19475 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19476 }
19477 arg2 = static_cast< int >(val2);
19478 }
19479 {
19480 PyThreadState* __tstate = wxPyBeginAllowThreads();
19481 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19482 wxPyEndAllowThreads(__tstate);
19483 if (PyErr_Occurred()) SWIG_fail;
19484 }
19485 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
19486 return resultobj;
19487 fail:
19488 return NULL;
19489 }
19490
19491
19492 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19493 PyObject *resultobj = 0;
19494 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19495 void *argp1 = 0 ;
19496 int res1 = 0 ;
19497 PyObject *swig_obj[1] ;
19498
19499 if (!args) SWIG_fail;
19500 swig_obj[0] = args;
19501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19502 if (!SWIG_IsOK(res1)) {
19503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19504 }
19505 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19506 {
19507 PyThreadState* __tstate = wxPyBeginAllowThreads();
19508 (arg1)->Veto();
19509 wxPyEndAllowThreads(__tstate);
19510 if (PyErr_Occurred()) SWIG_fail;
19511 }
19512 resultobj = SWIG_Py_Void();
19513 return resultobj;
19514 fail:
19515 return NULL;
19516 }
19517
19518
19519 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19520 PyObject *resultobj = 0;
19521 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19522 void *argp1 = 0 ;
19523 int res1 = 0 ;
19524 PyObject *swig_obj[1] ;
19525
19526 if (!args) SWIG_fail;
19527 swig_obj[0] = args;
19528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19529 if (!SWIG_IsOK(res1)) {
19530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19531 }
19532 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19533 {
19534 PyThreadState* __tstate = wxPyBeginAllowThreads();
19535 (arg1)->Allow();
19536 wxPyEndAllowThreads(__tstate);
19537 if (PyErr_Occurred()) SWIG_fail;
19538 }
19539 resultobj = SWIG_Py_Void();
19540 return resultobj;
19541 fail:
19542 return NULL;
19543 }
19544
19545
19546 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19547 PyObject *resultobj = 0;
19548 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19549 bool result;
19550 void *argp1 = 0 ;
19551 int res1 = 0 ;
19552 PyObject *swig_obj[1] ;
19553
19554 if (!args) SWIG_fail;
19555 swig_obj[0] = args;
19556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19557 if (!SWIG_IsOK(res1)) {
19558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19559 }
19560 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19561 {
19562 PyThreadState* __tstate = wxPyBeginAllowThreads();
19563 result = (bool)(arg1)->IsAllowed();
19564 wxPyEndAllowThreads(__tstate);
19565 if (PyErr_Occurred()) SWIG_fail;
19566 }
19567 {
19568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19569 }
19570 return resultobj;
19571 fail:
19572 return NULL;
19573 }
19574
19575
19576 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19577 PyObject *obj;
19578 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19579 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
19580 return SWIG_Py_Void();
19581 }
19582
19583 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19584 return SWIG_Python_InitShadowInstance(args);
19585 }
19586
19587 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19588 PyObject *resultobj = 0;
19589 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19590 int arg2 = (int) 0 ;
19591 int arg3 = (int) 0 ;
19592 int arg4 = (int) 0 ;
19593 wxScrollEvent *result = 0 ;
19594 int val1 ;
19595 int ecode1 = 0 ;
19596 int val2 ;
19597 int ecode2 = 0 ;
19598 int val3 ;
19599 int ecode3 = 0 ;
19600 int val4 ;
19601 int ecode4 = 0 ;
19602 PyObject * obj0 = 0 ;
19603 PyObject * obj1 = 0 ;
19604 PyObject * obj2 = 0 ;
19605 PyObject * obj3 = 0 ;
19606 char * kwnames[] = {
19607 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
19608 };
19609
19610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19611 if (obj0) {
19612 ecode1 = SWIG_AsVal_int(obj0, &val1);
19613 if (!SWIG_IsOK(ecode1)) {
19614 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19615 }
19616 arg1 = static_cast< wxEventType >(val1);
19617 }
19618 if (obj1) {
19619 ecode2 = SWIG_AsVal_int(obj1, &val2);
19620 if (!SWIG_IsOK(ecode2)) {
19621 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
19622 }
19623 arg2 = static_cast< int >(val2);
19624 }
19625 if (obj2) {
19626 ecode3 = SWIG_AsVal_int(obj2, &val3);
19627 if (!SWIG_IsOK(ecode3)) {
19628 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
19629 }
19630 arg3 = static_cast< int >(val3);
19631 }
19632 if (obj3) {
19633 ecode4 = SWIG_AsVal_int(obj3, &val4);
19634 if (!SWIG_IsOK(ecode4)) {
19635 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
19636 }
19637 arg4 = static_cast< int >(val4);
19638 }
19639 {
19640 PyThreadState* __tstate = wxPyBeginAllowThreads();
19641 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
19642 wxPyEndAllowThreads(__tstate);
19643 if (PyErr_Occurred()) SWIG_fail;
19644 }
19645 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
19646 return resultobj;
19647 fail:
19648 return NULL;
19649 }
19650
19651
19652 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19653 PyObject *resultobj = 0;
19654 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19655 int result;
19656 void *argp1 = 0 ;
19657 int res1 = 0 ;
19658 PyObject *swig_obj[1] ;
19659
19660 if (!args) SWIG_fail;
19661 swig_obj[0] = args;
19662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19663 if (!SWIG_IsOK(res1)) {
19664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19665 }
19666 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19667 {
19668 PyThreadState* __tstate = wxPyBeginAllowThreads();
19669 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
19670 wxPyEndAllowThreads(__tstate);
19671 if (PyErr_Occurred()) SWIG_fail;
19672 }
19673 resultobj = SWIG_From_int(static_cast< int >(result));
19674 return resultobj;
19675 fail:
19676 return NULL;
19677 }
19678
19679
19680 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19681 PyObject *resultobj = 0;
19682 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19683 int result;
19684 void *argp1 = 0 ;
19685 int res1 = 0 ;
19686 PyObject *swig_obj[1] ;
19687
19688 if (!args) SWIG_fail;
19689 swig_obj[0] = args;
19690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19691 if (!SWIG_IsOK(res1)) {
19692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19693 }
19694 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19695 {
19696 PyThreadState* __tstate = wxPyBeginAllowThreads();
19697 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
19698 wxPyEndAllowThreads(__tstate);
19699 if (PyErr_Occurred()) SWIG_fail;
19700 }
19701 resultobj = SWIG_From_int(static_cast< int >(result));
19702 return resultobj;
19703 fail:
19704 return NULL;
19705 }
19706
19707
19708 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19709 PyObject *resultobj = 0;
19710 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19711 int arg2 ;
19712 void *argp1 = 0 ;
19713 int res1 = 0 ;
19714 int val2 ;
19715 int ecode2 = 0 ;
19716 PyObject * obj0 = 0 ;
19717 PyObject * obj1 = 0 ;
19718 char * kwnames[] = {
19719 (char *) "self",(char *) "orient", NULL
19720 };
19721
19722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19724 if (!SWIG_IsOK(res1)) {
19725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19726 }
19727 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19728 ecode2 = SWIG_AsVal_int(obj1, &val2);
19729 if (!SWIG_IsOK(ecode2)) {
19730 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19731 }
19732 arg2 = static_cast< int >(val2);
19733 {
19734 PyThreadState* __tstate = wxPyBeginAllowThreads();
19735 (arg1)->SetOrientation(arg2);
19736 wxPyEndAllowThreads(__tstate);
19737 if (PyErr_Occurred()) SWIG_fail;
19738 }
19739 resultobj = SWIG_Py_Void();
19740 return resultobj;
19741 fail:
19742 return NULL;
19743 }
19744
19745
19746 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19747 PyObject *resultobj = 0;
19748 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19749 int arg2 ;
19750 void *argp1 = 0 ;
19751 int res1 = 0 ;
19752 int val2 ;
19753 int ecode2 = 0 ;
19754 PyObject * obj0 = 0 ;
19755 PyObject * obj1 = 0 ;
19756 char * kwnames[] = {
19757 (char *) "self",(char *) "pos", NULL
19758 };
19759
19760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19762 if (!SWIG_IsOK(res1)) {
19763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19764 }
19765 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19766 ecode2 = SWIG_AsVal_int(obj1, &val2);
19767 if (!SWIG_IsOK(ecode2)) {
19768 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19769 }
19770 arg2 = static_cast< int >(val2);
19771 {
19772 PyThreadState* __tstate = wxPyBeginAllowThreads();
19773 (arg1)->SetPosition(arg2);
19774 wxPyEndAllowThreads(__tstate);
19775 if (PyErr_Occurred()) SWIG_fail;
19776 }
19777 resultobj = SWIG_Py_Void();
19778 return resultobj;
19779 fail:
19780 return NULL;
19781 }
19782
19783
19784 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19785 PyObject *obj;
19786 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19787 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
19788 return SWIG_Py_Void();
19789 }
19790
19791 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19792 return SWIG_Python_InitShadowInstance(args);
19793 }
19794
19795 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19796 PyObject *resultobj = 0;
19797 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19798 int arg2 = (int) 0 ;
19799 int arg3 = (int) 0 ;
19800 wxScrollWinEvent *result = 0 ;
19801 int val1 ;
19802 int ecode1 = 0 ;
19803 int val2 ;
19804 int ecode2 = 0 ;
19805 int val3 ;
19806 int ecode3 = 0 ;
19807 PyObject * obj0 = 0 ;
19808 PyObject * obj1 = 0 ;
19809 PyObject * obj2 = 0 ;
19810 char * kwnames[] = {
19811 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
19812 };
19813
19814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19815 if (obj0) {
19816 ecode1 = SWIG_AsVal_int(obj0, &val1);
19817 if (!SWIG_IsOK(ecode1)) {
19818 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19819 }
19820 arg1 = static_cast< wxEventType >(val1);
19821 }
19822 if (obj1) {
19823 ecode2 = SWIG_AsVal_int(obj1, &val2);
19824 if (!SWIG_IsOK(ecode2)) {
19825 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
19826 }
19827 arg2 = static_cast< int >(val2);
19828 }
19829 if (obj2) {
19830 ecode3 = SWIG_AsVal_int(obj2, &val3);
19831 if (!SWIG_IsOK(ecode3)) {
19832 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
19833 }
19834 arg3 = static_cast< int >(val3);
19835 }
19836 {
19837 PyThreadState* __tstate = wxPyBeginAllowThreads();
19838 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
19839 wxPyEndAllowThreads(__tstate);
19840 if (PyErr_Occurred()) SWIG_fail;
19841 }
19842 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
19843 return resultobj;
19844 fail:
19845 return NULL;
19846 }
19847
19848
19849 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19850 PyObject *resultobj = 0;
19851 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19852 int result;
19853 void *argp1 = 0 ;
19854 int res1 = 0 ;
19855 PyObject *swig_obj[1] ;
19856
19857 if (!args) SWIG_fail;
19858 swig_obj[0] = args;
19859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19860 if (!SWIG_IsOK(res1)) {
19861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19862 }
19863 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19864 {
19865 PyThreadState* __tstate = wxPyBeginAllowThreads();
19866 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
19867 wxPyEndAllowThreads(__tstate);
19868 if (PyErr_Occurred()) SWIG_fail;
19869 }
19870 resultobj = SWIG_From_int(static_cast< int >(result));
19871 return resultobj;
19872 fail:
19873 return NULL;
19874 }
19875
19876
19877 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19878 PyObject *resultobj = 0;
19879 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19880 int result;
19881 void *argp1 = 0 ;
19882 int res1 = 0 ;
19883 PyObject *swig_obj[1] ;
19884
19885 if (!args) SWIG_fail;
19886 swig_obj[0] = args;
19887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19888 if (!SWIG_IsOK(res1)) {
19889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19890 }
19891 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19892 {
19893 PyThreadState* __tstate = wxPyBeginAllowThreads();
19894 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
19895 wxPyEndAllowThreads(__tstate);
19896 if (PyErr_Occurred()) SWIG_fail;
19897 }
19898 resultobj = SWIG_From_int(static_cast< int >(result));
19899 return resultobj;
19900 fail:
19901 return NULL;
19902 }
19903
19904
19905 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19906 PyObject *resultobj = 0;
19907 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19908 int arg2 ;
19909 void *argp1 = 0 ;
19910 int res1 = 0 ;
19911 int val2 ;
19912 int ecode2 = 0 ;
19913 PyObject * obj0 = 0 ;
19914 PyObject * obj1 = 0 ;
19915 char * kwnames[] = {
19916 (char *) "self",(char *) "orient", NULL
19917 };
19918
19919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19921 if (!SWIG_IsOK(res1)) {
19922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19923 }
19924 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19925 ecode2 = SWIG_AsVal_int(obj1, &val2);
19926 if (!SWIG_IsOK(ecode2)) {
19927 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19928 }
19929 arg2 = static_cast< int >(val2);
19930 {
19931 PyThreadState* __tstate = wxPyBeginAllowThreads();
19932 (arg1)->SetOrientation(arg2);
19933 wxPyEndAllowThreads(__tstate);
19934 if (PyErr_Occurred()) SWIG_fail;
19935 }
19936 resultobj = SWIG_Py_Void();
19937 return resultobj;
19938 fail:
19939 return NULL;
19940 }
19941
19942
19943 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19944 PyObject *resultobj = 0;
19945 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19946 int arg2 ;
19947 void *argp1 = 0 ;
19948 int res1 = 0 ;
19949 int val2 ;
19950 int ecode2 = 0 ;
19951 PyObject * obj0 = 0 ;
19952 PyObject * obj1 = 0 ;
19953 char * kwnames[] = {
19954 (char *) "self",(char *) "pos", NULL
19955 };
19956
19957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19959 if (!SWIG_IsOK(res1)) {
19960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19961 }
19962 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19963 ecode2 = SWIG_AsVal_int(obj1, &val2);
19964 if (!SWIG_IsOK(ecode2)) {
19965 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19966 }
19967 arg2 = static_cast< int >(val2);
19968 {
19969 PyThreadState* __tstate = wxPyBeginAllowThreads();
19970 (arg1)->SetPosition(arg2);
19971 wxPyEndAllowThreads(__tstate);
19972 if (PyErr_Occurred()) SWIG_fail;
19973 }
19974 resultobj = SWIG_Py_Void();
19975 return resultobj;
19976 fail:
19977 return NULL;
19978 }
19979
19980
19981 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19982 PyObject *obj;
19983 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19984 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
19985 return SWIG_Py_Void();
19986 }
19987
19988 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19989 return SWIG_Python_InitShadowInstance(args);
19990 }
19991
19992 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19993 PyObject *resultobj = 0;
19994 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19995 wxMouseEvent *result = 0 ;
19996 int val1 ;
19997 int ecode1 = 0 ;
19998 PyObject * obj0 = 0 ;
19999 char * kwnames[] = {
20000 (char *) "mouseType", NULL
20001 };
20002
20003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
20004 if (obj0) {
20005 ecode1 = SWIG_AsVal_int(obj0, &val1);
20006 if (!SWIG_IsOK(ecode1)) {
20007 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20008 }
20009 arg1 = static_cast< wxEventType >(val1);
20010 }
20011 {
20012 PyThreadState* __tstate = wxPyBeginAllowThreads();
20013 result = (wxMouseEvent *)new wxMouseEvent(arg1);
20014 wxPyEndAllowThreads(__tstate);
20015 if (PyErr_Occurred()) SWIG_fail;
20016 }
20017 {
20018 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
20019 }
20020 return resultobj;
20021 fail:
20022 return NULL;
20023 }
20024
20025
20026 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20027 PyObject *resultobj = 0;
20028 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20029 bool result;
20030 void *argp1 = 0 ;
20031 int res1 = 0 ;
20032 PyObject *swig_obj[1] ;
20033
20034 if (!args) SWIG_fail;
20035 swig_obj[0] = args;
20036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20037 if (!SWIG_IsOK(res1)) {
20038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20039 }
20040 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20041 {
20042 PyThreadState* __tstate = wxPyBeginAllowThreads();
20043 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
20044 wxPyEndAllowThreads(__tstate);
20045 if (PyErr_Occurred()) SWIG_fail;
20046 }
20047 {
20048 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20049 }
20050 return resultobj;
20051 fail:
20052 return NULL;
20053 }
20054
20055
20056 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20057 PyObject *resultobj = 0;
20058 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20059 int arg2 = (int) wxMOUSE_BTN_ANY ;
20060 bool result;
20061 void *argp1 = 0 ;
20062 int res1 = 0 ;
20063 int val2 ;
20064 int ecode2 = 0 ;
20065 PyObject * obj0 = 0 ;
20066 PyObject * obj1 = 0 ;
20067 char * kwnames[] = {
20068 (char *) "self",(char *) "but", NULL
20069 };
20070
20071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
20072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20073 if (!SWIG_IsOK(res1)) {
20074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20075 }
20076 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20077 if (obj1) {
20078 ecode2 = SWIG_AsVal_int(obj1, &val2);
20079 if (!SWIG_IsOK(ecode2)) {
20080 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
20081 }
20082 arg2 = static_cast< int >(val2);
20083 }
20084 {
20085 PyThreadState* __tstate = wxPyBeginAllowThreads();
20086 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
20087 wxPyEndAllowThreads(__tstate);
20088 if (PyErr_Occurred()) SWIG_fail;
20089 }
20090 {
20091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20092 }
20093 return resultobj;
20094 fail:
20095 return NULL;
20096 }
20097
20098
20099 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20100 PyObject *resultobj = 0;
20101 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20102 int arg2 = (int) wxMOUSE_BTN_ANY ;
20103 bool result;
20104 void *argp1 = 0 ;
20105 int res1 = 0 ;
20106 int val2 ;
20107 int ecode2 = 0 ;
20108 PyObject * obj0 = 0 ;
20109 PyObject * obj1 = 0 ;
20110 char * kwnames[] = {
20111 (char *) "self",(char *) "but", NULL
20112 };
20113
20114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
20115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20116 if (!SWIG_IsOK(res1)) {
20117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20118 }
20119 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20120 if (obj1) {
20121 ecode2 = SWIG_AsVal_int(obj1, &val2);
20122 if (!SWIG_IsOK(ecode2)) {
20123 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
20124 }
20125 arg2 = static_cast< int >(val2);
20126 }
20127 {
20128 PyThreadState* __tstate = wxPyBeginAllowThreads();
20129 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
20130 wxPyEndAllowThreads(__tstate);
20131 if (PyErr_Occurred()) SWIG_fail;
20132 }
20133 {
20134 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20135 }
20136 return resultobj;
20137 fail:
20138 return NULL;
20139 }
20140
20141
20142 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20143 PyObject *resultobj = 0;
20144 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20145 int arg2 = (int) wxMOUSE_BTN_ANY ;
20146 bool result;
20147 void *argp1 = 0 ;
20148 int res1 = 0 ;
20149 int val2 ;
20150 int ecode2 = 0 ;
20151 PyObject * obj0 = 0 ;
20152 PyObject * obj1 = 0 ;
20153 char * kwnames[] = {
20154 (char *) "self",(char *) "but", NULL
20155 };
20156
20157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
20158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20159 if (!SWIG_IsOK(res1)) {
20160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20161 }
20162 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20163 if (obj1) {
20164 ecode2 = SWIG_AsVal_int(obj1, &val2);
20165 if (!SWIG_IsOK(ecode2)) {
20166 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
20167 }
20168 arg2 = static_cast< int >(val2);
20169 }
20170 {
20171 PyThreadState* __tstate = wxPyBeginAllowThreads();
20172 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
20173 wxPyEndAllowThreads(__tstate);
20174 if (PyErr_Occurred()) SWIG_fail;
20175 }
20176 {
20177 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20178 }
20179 return resultobj;
20180 fail:
20181 return NULL;
20182 }
20183
20184
20185 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20186 PyObject *resultobj = 0;
20187 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20188 int arg2 ;
20189 bool result;
20190 void *argp1 = 0 ;
20191 int res1 = 0 ;
20192 int val2 ;
20193 int ecode2 = 0 ;
20194 PyObject * obj0 = 0 ;
20195 PyObject * obj1 = 0 ;
20196 char * kwnames[] = {
20197 (char *) "self",(char *) "button", NULL
20198 };
20199
20200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
20201 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20202 if (!SWIG_IsOK(res1)) {
20203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20204 }
20205 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20206 ecode2 = SWIG_AsVal_int(obj1, &val2);
20207 if (!SWIG_IsOK(ecode2)) {
20208 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
20209 }
20210 arg2 = static_cast< int >(val2);
20211 {
20212 PyThreadState* __tstate = wxPyBeginAllowThreads();
20213 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
20214 wxPyEndAllowThreads(__tstate);
20215 if (PyErr_Occurred()) SWIG_fail;
20216 }
20217 {
20218 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20219 }
20220 return resultobj;
20221 fail:
20222 return NULL;
20223 }
20224
20225
20226 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20227 PyObject *resultobj = 0;
20228 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20229 int arg2 ;
20230 bool result;
20231 void *argp1 = 0 ;
20232 int res1 = 0 ;
20233 int val2 ;
20234 int ecode2 = 0 ;
20235 PyObject * obj0 = 0 ;
20236 PyObject * obj1 = 0 ;
20237 char * kwnames[] = {
20238 (char *) "self",(char *) "but", NULL
20239 };
20240
20241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
20242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20243 if (!SWIG_IsOK(res1)) {
20244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20245 }
20246 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20247 ecode2 = SWIG_AsVal_int(obj1, &val2);
20248 if (!SWIG_IsOK(ecode2)) {
20249 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
20250 }
20251 arg2 = static_cast< int >(val2);
20252 {
20253 PyThreadState* __tstate = wxPyBeginAllowThreads();
20254 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20255 wxPyEndAllowThreads(__tstate);
20256 if (PyErr_Occurred()) SWIG_fail;
20257 }
20258 {
20259 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20260 }
20261 return resultobj;
20262 fail:
20263 return NULL;
20264 }
20265
20266
20267 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20268 PyObject *resultobj = 0;
20269 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20270 int result;
20271 void *argp1 = 0 ;
20272 int res1 = 0 ;
20273 PyObject *swig_obj[1] ;
20274
20275 if (!args) SWIG_fail;
20276 swig_obj[0] = args;
20277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20278 if (!SWIG_IsOK(res1)) {
20279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20280 }
20281 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20282 {
20283 PyThreadState* __tstate = wxPyBeginAllowThreads();
20284 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20285 wxPyEndAllowThreads(__tstate);
20286 if (PyErr_Occurred()) SWIG_fail;
20287 }
20288 resultobj = SWIG_From_int(static_cast< int >(result));
20289 return resultobj;
20290 fail:
20291 return NULL;
20292 }
20293
20294
20295 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20296 PyObject *resultobj = 0;
20297 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20298 bool result;
20299 void *argp1 = 0 ;
20300 int res1 = 0 ;
20301 PyObject *swig_obj[1] ;
20302
20303 if (!args) SWIG_fail;
20304 swig_obj[0] = args;
20305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20306 if (!SWIG_IsOK(res1)) {
20307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20308 }
20309 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20310 {
20311 PyThreadState* __tstate = wxPyBeginAllowThreads();
20312 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20313 wxPyEndAllowThreads(__tstate);
20314 if (PyErr_Occurred()) SWIG_fail;
20315 }
20316 {
20317 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20318 }
20319 return resultobj;
20320 fail:
20321 return NULL;
20322 }
20323
20324
20325 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20326 PyObject *resultobj = 0;
20327 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20328 bool result;
20329 void *argp1 = 0 ;
20330 int res1 = 0 ;
20331 PyObject *swig_obj[1] ;
20332
20333 if (!args) SWIG_fail;
20334 swig_obj[0] = args;
20335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20336 if (!SWIG_IsOK(res1)) {
20337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20338 }
20339 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20340 {
20341 PyThreadState* __tstate = wxPyBeginAllowThreads();
20342 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20343 wxPyEndAllowThreads(__tstate);
20344 if (PyErr_Occurred()) SWIG_fail;
20345 }
20346 {
20347 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20348 }
20349 return resultobj;
20350 fail:
20351 return NULL;
20352 }
20353
20354
20355 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20356 PyObject *resultobj = 0;
20357 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20358 bool result;
20359 void *argp1 = 0 ;
20360 int res1 = 0 ;
20361 PyObject *swig_obj[1] ;
20362
20363 if (!args) SWIG_fail;
20364 swig_obj[0] = args;
20365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20366 if (!SWIG_IsOK(res1)) {
20367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20368 }
20369 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20370 {
20371 PyThreadState* __tstate = wxPyBeginAllowThreads();
20372 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20373 wxPyEndAllowThreads(__tstate);
20374 if (PyErr_Occurred()) SWIG_fail;
20375 }
20376 {
20377 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20378 }
20379 return resultobj;
20380 fail:
20381 return NULL;
20382 }
20383
20384
20385 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20386 PyObject *resultobj = 0;
20387 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20388 bool result;
20389 void *argp1 = 0 ;
20390 int res1 = 0 ;
20391 PyObject *swig_obj[1] ;
20392
20393 if (!args) SWIG_fail;
20394 swig_obj[0] = args;
20395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20396 if (!SWIG_IsOK(res1)) {
20397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20398 }
20399 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20400 {
20401 PyThreadState* __tstate = wxPyBeginAllowThreads();
20402 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20403 wxPyEndAllowThreads(__tstate);
20404 if (PyErr_Occurred()) SWIG_fail;
20405 }
20406 {
20407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20408 }
20409 return resultobj;
20410 fail:
20411 return NULL;
20412 }
20413
20414
20415 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20416 PyObject *resultobj = 0;
20417 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20418 bool result;
20419 void *argp1 = 0 ;
20420 int res1 = 0 ;
20421 PyObject *swig_obj[1] ;
20422
20423 if (!args) SWIG_fail;
20424 swig_obj[0] = args;
20425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20426 if (!SWIG_IsOK(res1)) {
20427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20428 }
20429 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20430 {
20431 PyThreadState* __tstate = wxPyBeginAllowThreads();
20432 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20433 wxPyEndAllowThreads(__tstate);
20434 if (PyErr_Occurred()) SWIG_fail;
20435 }
20436 {
20437 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20438 }
20439 return resultobj;
20440 fail:
20441 return NULL;
20442 }
20443
20444
20445 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20446 PyObject *resultobj = 0;
20447 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20448 bool result;
20449 void *argp1 = 0 ;
20450 int res1 = 0 ;
20451 PyObject *swig_obj[1] ;
20452
20453 if (!args) SWIG_fail;
20454 swig_obj[0] = args;
20455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20456 if (!SWIG_IsOK(res1)) {
20457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20458 }
20459 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20460 {
20461 PyThreadState* __tstate = wxPyBeginAllowThreads();
20462 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20463 wxPyEndAllowThreads(__tstate);
20464 if (PyErr_Occurred()) SWIG_fail;
20465 }
20466 {
20467 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20468 }
20469 return resultobj;
20470 fail:
20471 return NULL;
20472 }
20473
20474
20475 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20476 PyObject *resultobj = 0;
20477 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20478 bool result;
20479 void *argp1 = 0 ;
20480 int res1 = 0 ;
20481 PyObject *swig_obj[1] ;
20482
20483 if (!args) SWIG_fail;
20484 swig_obj[0] = args;
20485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20486 if (!SWIG_IsOK(res1)) {
20487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20488 }
20489 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20490 {
20491 PyThreadState* __tstate = wxPyBeginAllowThreads();
20492 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
20493 wxPyEndAllowThreads(__tstate);
20494 if (PyErr_Occurred()) SWIG_fail;
20495 }
20496 {
20497 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20498 }
20499 return resultobj;
20500 fail:
20501 return NULL;
20502 }
20503
20504
20505 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20506 PyObject *resultobj = 0;
20507 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20508 bool result;
20509 void *argp1 = 0 ;
20510 int res1 = 0 ;
20511 PyObject *swig_obj[1] ;
20512
20513 if (!args) SWIG_fail;
20514 swig_obj[0] = args;
20515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20516 if (!SWIG_IsOK(res1)) {
20517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20518 }
20519 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20520 {
20521 PyThreadState* __tstate = wxPyBeginAllowThreads();
20522 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
20523 wxPyEndAllowThreads(__tstate);
20524 if (PyErr_Occurred()) SWIG_fail;
20525 }
20526 {
20527 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20528 }
20529 return resultobj;
20530 fail:
20531 return NULL;
20532 }
20533
20534
20535 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20536 PyObject *resultobj = 0;
20537 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20538 bool result;
20539 void *argp1 = 0 ;
20540 int res1 = 0 ;
20541 PyObject *swig_obj[1] ;
20542
20543 if (!args) SWIG_fail;
20544 swig_obj[0] = args;
20545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20546 if (!SWIG_IsOK(res1)) {
20547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20548 }
20549 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20550 {
20551 PyThreadState* __tstate = wxPyBeginAllowThreads();
20552 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
20553 wxPyEndAllowThreads(__tstate);
20554 if (PyErr_Occurred()) SWIG_fail;
20555 }
20556 {
20557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20558 }
20559 return resultobj;
20560 fail:
20561 return NULL;
20562 }
20563
20564
20565 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20566 PyObject *resultobj = 0;
20567 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20568 bool result;
20569 void *argp1 = 0 ;
20570 int res1 = 0 ;
20571 PyObject *swig_obj[1] ;
20572
20573 if (!args) SWIG_fail;
20574 swig_obj[0] = args;
20575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20576 if (!SWIG_IsOK(res1)) {
20577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20578 }
20579 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20580 {
20581 PyThreadState* __tstate = wxPyBeginAllowThreads();
20582 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
20583 wxPyEndAllowThreads(__tstate);
20584 if (PyErr_Occurred()) SWIG_fail;
20585 }
20586 {
20587 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20588 }
20589 return resultobj;
20590 fail:
20591 return NULL;
20592 }
20593
20594
20595 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20596 PyObject *resultobj = 0;
20597 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20598 bool result;
20599 void *argp1 = 0 ;
20600 int res1 = 0 ;
20601 PyObject *swig_obj[1] ;
20602
20603 if (!args) SWIG_fail;
20604 swig_obj[0] = args;
20605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20606 if (!SWIG_IsOK(res1)) {
20607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20608 }
20609 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20610 {
20611 PyThreadState* __tstate = wxPyBeginAllowThreads();
20612 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
20613 wxPyEndAllowThreads(__tstate);
20614 if (PyErr_Occurred()) SWIG_fail;
20615 }
20616 {
20617 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20618 }
20619 return resultobj;
20620 fail:
20621 return NULL;
20622 }
20623
20624
20625 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20626 PyObject *resultobj = 0;
20627 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20628 bool result;
20629 void *argp1 = 0 ;
20630 int res1 = 0 ;
20631 PyObject *swig_obj[1] ;
20632
20633 if (!args) SWIG_fail;
20634 swig_obj[0] = args;
20635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20636 if (!SWIG_IsOK(res1)) {
20637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20638 }
20639 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20640 {
20641 PyThreadState* __tstate = wxPyBeginAllowThreads();
20642 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
20643 wxPyEndAllowThreads(__tstate);
20644 if (PyErr_Occurred()) SWIG_fail;
20645 }
20646 {
20647 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20648 }
20649 return resultobj;
20650 fail:
20651 return NULL;
20652 }
20653
20654
20655 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20656 PyObject *resultobj = 0;
20657 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20658 bool result;
20659 void *argp1 = 0 ;
20660 int res1 = 0 ;
20661 PyObject *swig_obj[1] ;
20662
20663 if (!args) SWIG_fail;
20664 swig_obj[0] = args;
20665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20666 if (!SWIG_IsOK(res1)) {
20667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20668 }
20669 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20670 {
20671 PyThreadState* __tstate = wxPyBeginAllowThreads();
20672 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
20673 wxPyEndAllowThreads(__tstate);
20674 if (PyErr_Occurred()) SWIG_fail;
20675 }
20676 {
20677 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20678 }
20679 return resultobj;
20680 fail:
20681 return NULL;
20682 }
20683
20684
20685 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20686 PyObject *resultobj = 0;
20687 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20688 bool result;
20689 void *argp1 = 0 ;
20690 int res1 = 0 ;
20691 PyObject *swig_obj[1] ;
20692
20693 if (!args) SWIG_fail;
20694 swig_obj[0] = args;
20695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20696 if (!SWIG_IsOK(res1)) {
20697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20698 }
20699 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20700 {
20701 PyThreadState* __tstate = wxPyBeginAllowThreads();
20702 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
20703 wxPyEndAllowThreads(__tstate);
20704 if (PyErr_Occurred()) SWIG_fail;
20705 }
20706 {
20707 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20708 }
20709 return resultobj;
20710 fail:
20711 return NULL;
20712 }
20713
20714
20715 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20716 PyObject *resultobj = 0;
20717 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20718 bool result;
20719 void *argp1 = 0 ;
20720 int res1 = 0 ;
20721 PyObject *swig_obj[1] ;
20722
20723 if (!args) SWIG_fail;
20724 swig_obj[0] = args;
20725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20726 if (!SWIG_IsOK(res1)) {
20727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20728 }
20729 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20730 {
20731 PyThreadState* __tstate = wxPyBeginAllowThreads();
20732 result = (bool)(arg1)->LeftIsDown();
20733 wxPyEndAllowThreads(__tstate);
20734 if (PyErr_Occurred()) SWIG_fail;
20735 }
20736 {
20737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20738 }
20739 return resultobj;
20740 fail:
20741 return NULL;
20742 }
20743
20744
20745 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20746 PyObject *resultobj = 0;
20747 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20748 bool result;
20749 void *argp1 = 0 ;
20750 int res1 = 0 ;
20751 PyObject *swig_obj[1] ;
20752
20753 if (!args) SWIG_fail;
20754 swig_obj[0] = args;
20755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20756 if (!SWIG_IsOK(res1)) {
20757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20758 }
20759 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20760 {
20761 PyThreadState* __tstate = wxPyBeginAllowThreads();
20762 result = (bool)(arg1)->MiddleIsDown();
20763 wxPyEndAllowThreads(__tstate);
20764 if (PyErr_Occurred()) SWIG_fail;
20765 }
20766 {
20767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20768 }
20769 return resultobj;
20770 fail:
20771 return NULL;
20772 }
20773
20774
20775 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20776 PyObject *resultobj = 0;
20777 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20778 bool result;
20779 void *argp1 = 0 ;
20780 int res1 = 0 ;
20781 PyObject *swig_obj[1] ;
20782
20783 if (!args) SWIG_fail;
20784 swig_obj[0] = args;
20785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20786 if (!SWIG_IsOK(res1)) {
20787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20788 }
20789 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20790 {
20791 PyThreadState* __tstate = wxPyBeginAllowThreads();
20792 result = (bool)(arg1)->RightIsDown();
20793 wxPyEndAllowThreads(__tstate);
20794 if (PyErr_Occurred()) SWIG_fail;
20795 }
20796 {
20797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20798 }
20799 return resultobj;
20800 fail:
20801 return NULL;
20802 }
20803
20804
20805 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20806 PyObject *resultobj = 0;
20807 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20808 bool result;
20809 void *argp1 = 0 ;
20810 int res1 = 0 ;
20811 PyObject *swig_obj[1] ;
20812
20813 if (!args) SWIG_fail;
20814 swig_obj[0] = args;
20815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20816 if (!SWIG_IsOK(res1)) {
20817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20818 }
20819 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20820 {
20821 PyThreadState* __tstate = wxPyBeginAllowThreads();
20822 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
20823 wxPyEndAllowThreads(__tstate);
20824 if (PyErr_Occurred()) SWIG_fail;
20825 }
20826 {
20827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20828 }
20829 return resultobj;
20830 fail:
20831 return NULL;
20832 }
20833
20834
20835 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20836 PyObject *resultobj = 0;
20837 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20838 bool result;
20839 void *argp1 = 0 ;
20840 int res1 = 0 ;
20841 PyObject *swig_obj[1] ;
20842
20843 if (!args) SWIG_fail;
20844 swig_obj[0] = args;
20845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20846 if (!SWIG_IsOK(res1)) {
20847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20848 }
20849 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20850 {
20851 PyThreadState* __tstate = wxPyBeginAllowThreads();
20852 result = (bool)((wxMouseEvent const *)arg1)->Moving();
20853 wxPyEndAllowThreads(__tstate);
20854 if (PyErr_Occurred()) SWIG_fail;
20855 }
20856 {
20857 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20858 }
20859 return resultobj;
20860 fail:
20861 return NULL;
20862 }
20863
20864
20865 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20866 PyObject *resultobj = 0;
20867 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20868 bool result;
20869 void *argp1 = 0 ;
20870 int res1 = 0 ;
20871 PyObject *swig_obj[1] ;
20872
20873 if (!args) SWIG_fail;
20874 swig_obj[0] = args;
20875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20876 if (!SWIG_IsOK(res1)) {
20877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20878 }
20879 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20880 {
20881 PyThreadState* __tstate = wxPyBeginAllowThreads();
20882 result = (bool)((wxMouseEvent const *)arg1)->Entering();
20883 wxPyEndAllowThreads(__tstate);
20884 if (PyErr_Occurred()) SWIG_fail;
20885 }
20886 {
20887 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20888 }
20889 return resultobj;
20890 fail:
20891 return NULL;
20892 }
20893
20894
20895 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20896 PyObject *resultobj = 0;
20897 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20898 bool result;
20899 void *argp1 = 0 ;
20900 int res1 = 0 ;
20901 PyObject *swig_obj[1] ;
20902
20903 if (!args) SWIG_fail;
20904 swig_obj[0] = args;
20905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20906 if (!SWIG_IsOK(res1)) {
20907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20908 }
20909 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20910 {
20911 PyThreadState* __tstate = wxPyBeginAllowThreads();
20912 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
20913 wxPyEndAllowThreads(__tstate);
20914 if (PyErr_Occurred()) SWIG_fail;
20915 }
20916 {
20917 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20918 }
20919 return resultobj;
20920 fail:
20921 return NULL;
20922 }
20923
20924
20925 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20926 PyObject *resultobj = 0;
20927 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20928 wxPoint result;
20929 void *argp1 = 0 ;
20930 int res1 = 0 ;
20931 PyObject *swig_obj[1] ;
20932
20933 if (!args) SWIG_fail;
20934 swig_obj[0] = args;
20935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20936 if (!SWIG_IsOK(res1)) {
20937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20938 }
20939 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20940 {
20941 PyThreadState* __tstate = wxPyBeginAllowThreads();
20942 result = (arg1)->GetPosition();
20943 wxPyEndAllowThreads(__tstate);
20944 if (PyErr_Occurred()) SWIG_fail;
20945 }
20946 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20947 return resultobj;
20948 fail:
20949 return NULL;
20950 }
20951
20952
20953 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20954 PyObject *resultobj = 0;
20955 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20956 long *arg2 = (long *) 0 ;
20957 long *arg3 = (long *) 0 ;
20958 void *argp1 = 0 ;
20959 int res1 = 0 ;
20960 long temp2 ;
20961 int res2 = SWIG_TMPOBJ ;
20962 long temp3 ;
20963 int res3 = SWIG_TMPOBJ ;
20964 PyObject *swig_obj[1] ;
20965
20966 arg2 = &temp2;
20967 arg3 = &temp3;
20968 if (!args) SWIG_fail;
20969 swig_obj[0] = args;
20970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20971 if (!SWIG_IsOK(res1)) {
20972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20973 }
20974 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20975 {
20976 PyThreadState* __tstate = wxPyBeginAllowThreads();
20977 (arg1)->GetPosition(arg2,arg3);
20978 wxPyEndAllowThreads(__tstate);
20979 if (PyErr_Occurred()) SWIG_fail;
20980 }
20981 resultobj = SWIG_Py_Void();
20982 if (SWIG_IsTmpObj(res2)) {
20983 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
20984 } else {
20985 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20986 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
20987 }
20988 if (SWIG_IsTmpObj(res3)) {
20989 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
20990 } else {
20991 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20992 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
20993 }
20994 return resultobj;
20995 fail:
20996 return NULL;
20997 }
20998
20999
21000 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21001 PyObject *resultobj = 0;
21002 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21003 wxDC *arg2 = 0 ;
21004 wxPoint result;
21005 void *argp1 = 0 ;
21006 int res1 = 0 ;
21007 void *argp2 = 0 ;
21008 int res2 = 0 ;
21009 PyObject * obj0 = 0 ;
21010 PyObject * obj1 = 0 ;
21011 char * kwnames[] = {
21012 (char *) "self",(char *) "dc", NULL
21013 };
21014
21015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
21016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21017 if (!SWIG_IsOK(res1)) {
21018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21019 }
21020 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21021 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
21022 if (!SWIG_IsOK(res2)) {
21023 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
21024 }
21025 if (!argp2) {
21026 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
21027 }
21028 arg2 = reinterpret_cast< wxDC * >(argp2);
21029 {
21030 PyThreadState* __tstate = wxPyBeginAllowThreads();
21031 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
21032 wxPyEndAllowThreads(__tstate);
21033 if (PyErr_Occurred()) SWIG_fail;
21034 }
21035 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
21036 return resultobj;
21037 fail:
21038 return NULL;
21039 }
21040
21041
21042 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21043 PyObject *resultobj = 0;
21044 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21045 int result;
21046 void *argp1 = 0 ;
21047 int res1 = 0 ;
21048 PyObject *swig_obj[1] ;
21049
21050 if (!args) SWIG_fail;
21051 swig_obj[0] = args;
21052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21053 if (!SWIG_IsOK(res1)) {
21054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21055 }
21056 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21057 {
21058 PyThreadState* __tstate = wxPyBeginAllowThreads();
21059 result = (int)((wxMouseEvent const *)arg1)->GetX();
21060 wxPyEndAllowThreads(__tstate);
21061 if (PyErr_Occurred()) SWIG_fail;
21062 }
21063 resultobj = SWIG_From_int(static_cast< int >(result));
21064 return resultobj;
21065 fail:
21066 return NULL;
21067 }
21068
21069
21070 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21071 PyObject *resultobj = 0;
21072 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21073 int result;
21074 void *argp1 = 0 ;
21075 int res1 = 0 ;
21076 PyObject *swig_obj[1] ;
21077
21078 if (!args) SWIG_fail;
21079 swig_obj[0] = args;
21080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21081 if (!SWIG_IsOK(res1)) {
21082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21083 }
21084 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21085 {
21086 PyThreadState* __tstate = wxPyBeginAllowThreads();
21087 result = (int)((wxMouseEvent const *)arg1)->GetY();
21088 wxPyEndAllowThreads(__tstate);
21089 if (PyErr_Occurred()) SWIG_fail;
21090 }
21091 resultobj = SWIG_From_int(static_cast< int >(result));
21092 return resultobj;
21093 fail:
21094 return NULL;
21095 }
21096
21097
21098 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21099 PyObject *resultobj = 0;
21100 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21101 int 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_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21111 }
21112 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21113 {
21114 PyThreadState* __tstate = wxPyBeginAllowThreads();
21115 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
21116 wxPyEndAllowThreads(__tstate);
21117 if (PyErr_Occurred()) SWIG_fail;
21118 }
21119 resultobj = SWIG_From_int(static_cast< int >(result));
21120 return resultobj;
21121 fail:
21122 return NULL;
21123 }
21124
21125
21126 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21127 PyObject *resultobj = 0;
21128 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21129 int result;
21130 void *argp1 = 0 ;
21131 int res1 = 0 ;
21132 PyObject *swig_obj[1] ;
21133
21134 if (!args) SWIG_fail;
21135 swig_obj[0] = args;
21136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21137 if (!SWIG_IsOK(res1)) {
21138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21139 }
21140 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21141 {
21142 PyThreadState* __tstate = wxPyBeginAllowThreads();
21143 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
21144 wxPyEndAllowThreads(__tstate);
21145 if (PyErr_Occurred()) SWIG_fail;
21146 }
21147 resultobj = SWIG_From_int(static_cast< int >(result));
21148 return resultobj;
21149 fail:
21150 return NULL;
21151 }
21152
21153
21154 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21155 PyObject *resultobj = 0;
21156 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21157 int result;
21158 void *argp1 = 0 ;
21159 int res1 = 0 ;
21160 PyObject *swig_obj[1] ;
21161
21162 if (!args) SWIG_fail;
21163 swig_obj[0] = args;
21164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21165 if (!SWIG_IsOK(res1)) {
21166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21167 }
21168 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21169 {
21170 PyThreadState* __tstate = wxPyBeginAllowThreads();
21171 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
21172 wxPyEndAllowThreads(__tstate);
21173 if (PyErr_Occurred()) SWIG_fail;
21174 }
21175 resultobj = SWIG_From_int(static_cast< int >(result));
21176 return resultobj;
21177 fail:
21178 return NULL;
21179 }
21180
21181
21182 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21183 PyObject *resultobj = 0;
21184 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21185 bool result;
21186 void *argp1 = 0 ;
21187 int res1 = 0 ;
21188 PyObject *swig_obj[1] ;
21189
21190 if (!args) SWIG_fail;
21191 swig_obj[0] = args;
21192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21193 if (!SWIG_IsOK(res1)) {
21194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21195 }
21196 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21197 {
21198 PyThreadState* __tstate = wxPyBeginAllowThreads();
21199 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
21200 wxPyEndAllowThreads(__tstate);
21201 if (PyErr_Occurred()) SWIG_fail;
21202 }
21203 {
21204 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21205 }
21206 return resultobj;
21207 fail:
21208 return NULL;
21209 }
21210
21211
21212 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21213 PyObject *resultobj = 0;
21214 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21215 int arg2 ;
21216 void *argp1 = 0 ;
21217 int res1 = 0 ;
21218 int val2 ;
21219 int ecode2 = 0 ;
21220 PyObject *swig_obj[2] ;
21221
21222 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
21223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21224 if (!SWIG_IsOK(res1)) {
21225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21226 }
21227 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21228 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21229 if (!SWIG_IsOK(ecode2)) {
21230 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
21231 }
21232 arg2 = static_cast< int >(val2);
21233 if (arg1) (arg1)->m_x = arg2;
21234
21235 resultobj = SWIG_Py_Void();
21236 return resultobj;
21237 fail:
21238 return NULL;
21239 }
21240
21241
21242 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21243 PyObject *resultobj = 0;
21244 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21245 int result;
21246 void *argp1 = 0 ;
21247 int res1 = 0 ;
21248 PyObject *swig_obj[1] ;
21249
21250 if (!args) SWIG_fail;
21251 swig_obj[0] = args;
21252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21253 if (!SWIG_IsOK(res1)) {
21254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21255 }
21256 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21257 result = (int) ((arg1)->m_x);
21258 resultobj = SWIG_From_int(static_cast< int >(result));
21259 return resultobj;
21260 fail:
21261 return NULL;
21262 }
21263
21264
21265 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21266 PyObject *resultobj = 0;
21267 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21268 int arg2 ;
21269 void *argp1 = 0 ;
21270 int res1 = 0 ;
21271 int val2 ;
21272 int ecode2 = 0 ;
21273 PyObject *swig_obj[2] ;
21274
21275 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
21276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21277 if (!SWIG_IsOK(res1)) {
21278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21279 }
21280 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21281 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21282 if (!SWIG_IsOK(ecode2)) {
21283 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21284 }
21285 arg2 = static_cast< int >(val2);
21286 if (arg1) (arg1)->m_y = arg2;
21287
21288 resultobj = SWIG_Py_Void();
21289 return resultobj;
21290 fail:
21291 return NULL;
21292 }
21293
21294
21295 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21296 PyObject *resultobj = 0;
21297 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21298 int result;
21299 void *argp1 = 0 ;
21300 int res1 = 0 ;
21301 PyObject *swig_obj[1] ;
21302
21303 if (!args) SWIG_fail;
21304 swig_obj[0] = args;
21305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21306 if (!SWIG_IsOK(res1)) {
21307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21308 }
21309 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21310 result = (int) ((arg1)->m_y);
21311 resultobj = SWIG_From_int(static_cast< int >(result));
21312 return resultobj;
21313 fail:
21314 return NULL;
21315 }
21316
21317
21318 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21319 PyObject *resultobj = 0;
21320 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21321 bool arg2 ;
21322 void *argp1 = 0 ;
21323 int res1 = 0 ;
21324 bool val2 ;
21325 int ecode2 = 0 ;
21326 PyObject *swig_obj[2] ;
21327
21328 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21330 if (!SWIG_IsOK(res1)) {
21331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21332 }
21333 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21334 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21335 if (!SWIG_IsOK(ecode2)) {
21336 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21337 }
21338 arg2 = static_cast< bool >(val2);
21339 if (arg1) (arg1)->m_leftDown = arg2;
21340
21341 resultobj = SWIG_Py_Void();
21342 return resultobj;
21343 fail:
21344 return NULL;
21345 }
21346
21347
21348 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21349 PyObject *resultobj = 0;
21350 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21351 bool result;
21352 void *argp1 = 0 ;
21353 int res1 = 0 ;
21354 PyObject *swig_obj[1] ;
21355
21356 if (!args) SWIG_fail;
21357 swig_obj[0] = args;
21358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21359 if (!SWIG_IsOK(res1)) {
21360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21361 }
21362 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21363 result = (bool) ((arg1)->m_leftDown);
21364 {
21365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21366 }
21367 return resultobj;
21368 fail:
21369 return NULL;
21370 }
21371
21372
21373 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21374 PyObject *resultobj = 0;
21375 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21376 bool arg2 ;
21377 void *argp1 = 0 ;
21378 int res1 = 0 ;
21379 bool val2 ;
21380 int ecode2 = 0 ;
21381 PyObject *swig_obj[2] ;
21382
21383 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21385 if (!SWIG_IsOK(res1)) {
21386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21387 }
21388 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21389 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21390 if (!SWIG_IsOK(ecode2)) {
21391 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21392 }
21393 arg2 = static_cast< bool >(val2);
21394 if (arg1) (arg1)->m_middleDown = arg2;
21395
21396 resultobj = SWIG_Py_Void();
21397 return resultobj;
21398 fail:
21399 return NULL;
21400 }
21401
21402
21403 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21404 PyObject *resultobj = 0;
21405 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21406 bool result;
21407 void *argp1 = 0 ;
21408 int res1 = 0 ;
21409 PyObject *swig_obj[1] ;
21410
21411 if (!args) SWIG_fail;
21412 swig_obj[0] = args;
21413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21414 if (!SWIG_IsOK(res1)) {
21415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21416 }
21417 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21418 result = (bool) ((arg1)->m_middleDown);
21419 {
21420 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21421 }
21422 return resultobj;
21423 fail:
21424 return NULL;
21425 }
21426
21427
21428 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21429 PyObject *resultobj = 0;
21430 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21431 bool arg2 ;
21432 void *argp1 = 0 ;
21433 int res1 = 0 ;
21434 bool val2 ;
21435 int ecode2 = 0 ;
21436 PyObject *swig_obj[2] ;
21437
21438 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21440 if (!SWIG_IsOK(res1)) {
21441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21442 }
21443 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21444 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21445 if (!SWIG_IsOK(ecode2)) {
21446 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21447 }
21448 arg2 = static_cast< bool >(val2);
21449 if (arg1) (arg1)->m_rightDown = arg2;
21450
21451 resultobj = SWIG_Py_Void();
21452 return resultobj;
21453 fail:
21454 return NULL;
21455 }
21456
21457
21458 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21459 PyObject *resultobj = 0;
21460 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21461 bool result;
21462 void *argp1 = 0 ;
21463 int res1 = 0 ;
21464 PyObject *swig_obj[1] ;
21465
21466 if (!args) SWIG_fail;
21467 swig_obj[0] = args;
21468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21469 if (!SWIG_IsOK(res1)) {
21470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21471 }
21472 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21473 result = (bool) ((arg1)->m_rightDown);
21474 {
21475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21476 }
21477 return resultobj;
21478 fail:
21479 return NULL;
21480 }
21481
21482
21483 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21484 PyObject *resultobj = 0;
21485 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21486 bool arg2 ;
21487 void *argp1 = 0 ;
21488 int res1 = 0 ;
21489 bool val2 ;
21490 int ecode2 = 0 ;
21491 PyObject *swig_obj[2] ;
21492
21493 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
21494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21495 if (!SWIG_IsOK(res1)) {
21496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21497 }
21498 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21499 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21500 if (!SWIG_IsOK(ecode2)) {
21501 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
21502 }
21503 arg2 = static_cast< bool >(val2);
21504 if (arg1) (arg1)->m_controlDown = arg2;
21505
21506 resultobj = SWIG_Py_Void();
21507 return resultobj;
21508 fail:
21509 return NULL;
21510 }
21511
21512
21513 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21514 PyObject *resultobj = 0;
21515 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21516 bool result;
21517 void *argp1 = 0 ;
21518 int res1 = 0 ;
21519 PyObject *swig_obj[1] ;
21520
21521 if (!args) SWIG_fail;
21522 swig_obj[0] = args;
21523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21524 if (!SWIG_IsOK(res1)) {
21525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21526 }
21527 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21528 result = (bool) ((arg1)->m_controlDown);
21529 {
21530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21531 }
21532 return resultobj;
21533 fail:
21534 return NULL;
21535 }
21536
21537
21538 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21539 PyObject *resultobj = 0;
21540 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21541 bool arg2 ;
21542 void *argp1 = 0 ;
21543 int res1 = 0 ;
21544 bool val2 ;
21545 int ecode2 = 0 ;
21546 PyObject *swig_obj[2] ;
21547
21548 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
21549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21550 if (!SWIG_IsOK(res1)) {
21551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21552 }
21553 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21554 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21555 if (!SWIG_IsOK(ecode2)) {
21556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
21557 }
21558 arg2 = static_cast< bool >(val2);
21559 if (arg1) (arg1)->m_shiftDown = arg2;
21560
21561 resultobj = SWIG_Py_Void();
21562 return resultobj;
21563 fail:
21564 return NULL;
21565 }
21566
21567
21568 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21569 PyObject *resultobj = 0;
21570 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21571 bool result;
21572 void *argp1 = 0 ;
21573 int res1 = 0 ;
21574 PyObject *swig_obj[1] ;
21575
21576 if (!args) SWIG_fail;
21577 swig_obj[0] = args;
21578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21579 if (!SWIG_IsOK(res1)) {
21580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21581 }
21582 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21583 result = (bool) ((arg1)->m_shiftDown);
21584 {
21585 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21586 }
21587 return resultobj;
21588 fail:
21589 return NULL;
21590 }
21591
21592
21593 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21594 PyObject *resultobj = 0;
21595 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21596 bool arg2 ;
21597 void *argp1 = 0 ;
21598 int res1 = 0 ;
21599 bool val2 ;
21600 int ecode2 = 0 ;
21601 PyObject *swig_obj[2] ;
21602
21603 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
21604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21605 if (!SWIG_IsOK(res1)) {
21606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21607 }
21608 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21609 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21610 if (!SWIG_IsOK(ecode2)) {
21611 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
21612 }
21613 arg2 = static_cast< bool >(val2);
21614 if (arg1) (arg1)->m_altDown = arg2;
21615
21616 resultobj = SWIG_Py_Void();
21617 return resultobj;
21618 fail:
21619 return NULL;
21620 }
21621
21622
21623 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21624 PyObject *resultobj = 0;
21625 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21626 bool result;
21627 void *argp1 = 0 ;
21628 int res1 = 0 ;
21629 PyObject *swig_obj[1] ;
21630
21631 if (!args) SWIG_fail;
21632 swig_obj[0] = args;
21633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21634 if (!SWIG_IsOK(res1)) {
21635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21636 }
21637 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21638 result = (bool) ((arg1)->m_altDown);
21639 {
21640 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21641 }
21642 return resultobj;
21643 fail:
21644 return NULL;
21645 }
21646
21647
21648 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21649 PyObject *resultobj = 0;
21650 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21651 bool arg2 ;
21652 void *argp1 = 0 ;
21653 int res1 = 0 ;
21654 bool val2 ;
21655 int ecode2 = 0 ;
21656 PyObject *swig_obj[2] ;
21657
21658 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
21659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21660 if (!SWIG_IsOK(res1)) {
21661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21662 }
21663 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21664 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21665 if (!SWIG_IsOK(ecode2)) {
21666 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
21667 }
21668 arg2 = static_cast< bool >(val2);
21669 if (arg1) (arg1)->m_metaDown = arg2;
21670
21671 resultobj = SWIG_Py_Void();
21672 return resultobj;
21673 fail:
21674 return NULL;
21675 }
21676
21677
21678 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21679 PyObject *resultobj = 0;
21680 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21681 bool result;
21682 void *argp1 = 0 ;
21683 int res1 = 0 ;
21684 PyObject *swig_obj[1] ;
21685
21686 if (!args) SWIG_fail;
21687 swig_obj[0] = args;
21688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21689 if (!SWIG_IsOK(res1)) {
21690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21691 }
21692 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21693 result = (bool) ((arg1)->m_metaDown);
21694 {
21695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21696 }
21697 return resultobj;
21698 fail:
21699 return NULL;
21700 }
21701
21702
21703 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21704 PyObject *resultobj = 0;
21705 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21706 int arg2 ;
21707 void *argp1 = 0 ;
21708 int res1 = 0 ;
21709 int val2 ;
21710 int ecode2 = 0 ;
21711 PyObject *swig_obj[2] ;
21712
21713 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
21714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21715 if (!SWIG_IsOK(res1)) {
21716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21717 }
21718 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21719 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21720 if (!SWIG_IsOK(ecode2)) {
21721 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
21722 }
21723 arg2 = static_cast< int >(val2);
21724 if (arg1) (arg1)->m_wheelRotation = arg2;
21725
21726 resultobj = SWIG_Py_Void();
21727 return resultobj;
21728 fail:
21729 return NULL;
21730 }
21731
21732
21733 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21734 PyObject *resultobj = 0;
21735 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21736 int result;
21737 void *argp1 = 0 ;
21738 int res1 = 0 ;
21739 PyObject *swig_obj[1] ;
21740
21741 if (!args) SWIG_fail;
21742 swig_obj[0] = args;
21743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21744 if (!SWIG_IsOK(res1)) {
21745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21746 }
21747 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21748 result = (int) ((arg1)->m_wheelRotation);
21749 resultobj = SWIG_From_int(static_cast< int >(result));
21750 return resultobj;
21751 fail:
21752 return NULL;
21753 }
21754
21755
21756 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21757 PyObject *resultobj = 0;
21758 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21759 int arg2 ;
21760 void *argp1 = 0 ;
21761 int res1 = 0 ;
21762 int val2 ;
21763 int ecode2 = 0 ;
21764 PyObject *swig_obj[2] ;
21765
21766 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
21767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21768 if (!SWIG_IsOK(res1)) {
21769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21770 }
21771 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21772 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21773 if (!SWIG_IsOK(ecode2)) {
21774 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
21775 }
21776 arg2 = static_cast< int >(val2);
21777 if (arg1) (arg1)->m_wheelDelta = arg2;
21778
21779 resultobj = SWIG_Py_Void();
21780 return resultobj;
21781 fail:
21782 return NULL;
21783 }
21784
21785
21786 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21787 PyObject *resultobj = 0;
21788 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21789 int result;
21790 void *argp1 = 0 ;
21791 int res1 = 0 ;
21792 PyObject *swig_obj[1] ;
21793
21794 if (!args) SWIG_fail;
21795 swig_obj[0] = args;
21796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21797 if (!SWIG_IsOK(res1)) {
21798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21799 }
21800 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21801 result = (int) ((arg1)->m_wheelDelta);
21802 resultobj = SWIG_From_int(static_cast< int >(result));
21803 return resultobj;
21804 fail:
21805 return NULL;
21806 }
21807
21808
21809 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21810 PyObject *resultobj = 0;
21811 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21812 int arg2 ;
21813 void *argp1 = 0 ;
21814 int res1 = 0 ;
21815 int val2 ;
21816 int ecode2 = 0 ;
21817 PyObject *swig_obj[2] ;
21818
21819 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
21820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21821 if (!SWIG_IsOK(res1)) {
21822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21823 }
21824 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21825 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21826 if (!SWIG_IsOK(ecode2)) {
21827 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
21828 }
21829 arg2 = static_cast< int >(val2);
21830 if (arg1) (arg1)->m_linesPerAction = arg2;
21831
21832 resultobj = SWIG_Py_Void();
21833 return resultobj;
21834 fail:
21835 return NULL;
21836 }
21837
21838
21839 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21840 PyObject *resultobj = 0;
21841 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21842 int result;
21843 void *argp1 = 0 ;
21844 int res1 = 0 ;
21845 PyObject *swig_obj[1] ;
21846
21847 if (!args) SWIG_fail;
21848 swig_obj[0] = args;
21849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21850 if (!SWIG_IsOK(res1)) {
21851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21852 }
21853 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21854 result = (int) ((arg1)->m_linesPerAction);
21855 resultobj = SWIG_From_int(static_cast< int >(result));
21856 return resultobj;
21857 fail:
21858 return NULL;
21859 }
21860
21861
21862 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21863 PyObject *obj;
21864 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21865 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
21866 return SWIG_Py_Void();
21867 }
21868
21869 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21870 return SWIG_Python_InitShadowInstance(args);
21871 }
21872
21873 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21874 PyObject *resultobj = 0;
21875 int arg1 = (int) 0 ;
21876 int arg2 = (int) 0 ;
21877 wxSetCursorEvent *result = 0 ;
21878 int val1 ;
21879 int ecode1 = 0 ;
21880 int val2 ;
21881 int ecode2 = 0 ;
21882 PyObject * obj0 = 0 ;
21883 PyObject * obj1 = 0 ;
21884 char * kwnames[] = {
21885 (char *) "x",(char *) "y", NULL
21886 };
21887
21888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21889 if (obj0) {
21890 ecode1 = SWIG_AsVal_int(obj0, &val1);
21891 if (!SWIG_IsOK(ecode1)) {
21892 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
21893 }
21894 arg1 = static_cast< int >(val1);
21895 }
21896 if (obj1) {
21897 ecode2 = SWIG_AsVal_int(obj1, &val2);
21898 if (!SWIG_IsOK(ecode2)) {
21899 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
21900 }
21901 arg2 = static_cast< int >(val2);
21902 }
21903 {
21904 PyThreadState* __tstate = wxPyBeginAllowThreads();
21905 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
21906 wxPyEndAllowThreads(__tstate);
21907 if (PyErr_Occurred()) SWIG_fail;
21908 }
21909 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
21910 return resultobj;
21911 fail:
21912 return NULL;
21913 }
21914
21915
21916 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21917 PyObject *resultobj = 0;
21918 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21919 int result;
21920 void *argp1 = 0 ;
21921 int res1 = 0 ;
21922 PyObject *swig_obj[1] ;
21923
21924 if (!args) SWIG_fail;
21925 swig_obj[0] = args;
21926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21927 if (!SWIG_IsOK(res1)) {
21928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21929 }
21930 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21931 {
21932 PyThreadState* __tstate = wxPyBeginAllowThreads();
21933 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
21934 wxPyEndAllowThreads(__tstate);
21935 if (PyErr_Occurred()) SWIG_fail;
21936 }
21937 resultobj = SWIG_From_int(static_cast< int >(result));
21938 return resultobj;
21939 fail:
21940 return NULL;
21941 }
21942
21943
21944 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21945 PyObject *resultobj = 0;
21946 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21947 int result;
21948 void *argp1 = 0 ;
21949 int res1 = 0 ;
21950 PyObject *swig_obj[1] ;
21951
21952 if (!args) SWIG_fail;
21953 swig_obj[0] = args;
21954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21955 if (!SWIG_IsOK(res1)) {
21956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21957 }
21958 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21959 {
21960 PyThreadState* __tstate = wxPyBeginAllowThreads();
21961 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
21962 wxPyEndAllowThreads(__tstate);
21963 if (PyErr_Occurred()) SWIG_fail;
21964 }
21965 resultobj = SWIG_From_int(static_cast< int >(result));
21966 return resultobj;
21967 fail:
21968 return NULL;
21969 }
21970
21971
21972 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21973 PyObject *resultobj = 0;
21974 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21975 wxCursor *arg2 = 0 ;
21976 void *argp1 = 0 ;
21977 int res1 = 0 ;
21978 void *argp2 = 0 ;
21979 int res2 = 0 ;
21980 PyObject * obj0 = 0 ;
21981 PyObject * obj1 = 0 ;
21982 char * kwnames[] = {
21983 (char *) "self",(char *) "cursor", NULL
21984 };
21985
21986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
21987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21988 if (!SWIG_IsOK(res1)) {
21989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
21990 }
21991 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21992 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
21993 if (!SWIG_IsOK(res2)) {
21994 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21995 }
21996 if (!argp2) {
21997 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21998 }
21999 arg2 = reinterpret_cast< wxCursor * >(argp2);
22000 {
22001 PyThreadState* __tstate = wxPyBeginAllowThreads();
22002 (arg1)->SetCursor((wxCursor const &)*arg2);
22003 wxPyEndAllowThreads(__tstate);
22004 if (PyErr_Occurred()) SWIG_fail;
22005 }
22006 resultobj = SWIG_Py_Void();
22007 return resultobj;
22008 fail:
22009 return NULL;
22010 }
22011
22012
22013 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22014 PyObject *resultobj = 0;
22015 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22016 wxCursor *result = 0 ;
22017 void *argp1 = 0 ;
22018 int res1 = 0 ;
22019 PyObject *swig_obj[1] ;
22020
22021 if (!args) SWIG_fail;
22022 swig_obj[0] = args;
22023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22024 if (!SWIG_IsOK(res1)) {
22025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22026 }
22027 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22028 {
22029 PyThreadState* __tstate = wxPyBeginAllowThreads();
22030 {
22031 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
22032 result = (wxCursor *) &_result_ref;
22033 }
22034 wxPyEndAllowThreads(__tstate);
22035 if (PyErr_Occurred()) SWIG_fail;
22036 }
22037 {
22038 wxCursor* resultptr = new wxCursor(*result);
22039 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
22040 }
22041 return resultobj;
22042 fail:
22043 return NULL;
22044 }
22045
22046
22047 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22048 PyObject *resultobj = 0;
22049 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22050 bool result;
22051 void *argp1 = 0 ;
22052 int res1 = 0 ;
22053 PyObject *swig_obj[1] ;
22054
22055 if (!args) SWIG_fail;
22056 swig_obj[0] = args;
22057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22058 if (!SWIG_IsOK(res1)) {
22059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22060 }
22061 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22062 {
22063 PyThreadState* __tstate = wxPyBeginAllowThreads();
22064 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
22065 wxPyEndAllowThreads(__tstate);
22066 if (PyErr_Occurred()) SWIG_fail;
22067 }
22068 {
22069 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22070 }
22071 return resultobj;
22072 fail:
22073 return NULL;
22074 }
22075
22076
22077 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22078 PyObject *obj;
22079 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22080 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
22081 return SWIG_Py_Void();
22082 }
22083
22084 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22085 return SWIG_Python_InitShadowInstance(args);
22086 }
22087
22088 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22089 PyObject *resultobj = 0;
22090 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22091 wxKeyEvent *result = 0 ;
22092 int val1 ;
22093 int ecode1 = 0 ;
22094 PyObject * obj0 = 0 ;
22095 char * kwnames[] = {
22096 (char *) "eventType", NULL
22097 };
22098
22099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
22100 if (obj0) {
22101 ecode1 = SWIG_AsVal_int(obj0, &val1);
22102 if (!SWIG_IsOK(ecode1)) {
22103 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22104 }
22105 arg1 = static_cast< wxEventType >(val1);
22106 }
22107 {
22108 PyThreadState* __tstate = wxPyBeginAllowThreads();
22109 result = (wxKeyEvent *)new wxKeyEvent(arg1);
22110 wxPyEndAllowThreads(__tstate);
22111 if (PyErr_Occurred()) SWIG_fail;
22112 }
22113 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
22114 return resultobj;
22115 fail:
22116 return NULL;
22117 }
22118
22119
22120 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22121 PyObject *resultobj = 0;
22122 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22123 int result;
22124 void *argp1 = 0 ;
22125 int res1 = 0 ;
22126 PyObject *swig_obj[1] ;
22127
22128 if (!args) SWIG_fail;
22129 swig_obj[0] = args;
22130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22131 if (!SWIG_IsOK(res1)) {
22132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22133 }
22134 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22135 {
22136 PyThreadState* __tstate = wxPyBeginAllowThreads();
22137 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
22138 wxPyEndAllowThreads(__tstate);
22139 if (PyErr_Occurred()) SWIG_fail;
22140 }
22141 resultobj = SWIG_From_int(static_cast< int >(result));
22142 return resultobj;
22143 fail:
22144 return NULL;
22145 }
22146
22147
22148 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22149 PyObject *resultobj = 0;
22150 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22151 bool result;
22152 void *argp1 = 0 ;
22153 int res1 = 0 ;
22154 PyObject *swig_obj[1] ;
22155
22156 if (!args) SWIG_fail;
22157 swig_obj[0] = args;
22158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22159 if (!SWIG_IsOK(res1)) {
22160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22161 }
22162 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22163 {
22164 PyThreadState* __tstate = wxPyBeginAllowThreads();
22165 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
22166 wxPyEndAllowThreads(__tstate);
22167 if (PyErr_Occurred()) SWIG_fail;
22168 }
22169 {
22170 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22171 }
22172 return resultobj;
22173 fail:
22174 return NULL;
22175 }
22176
22177
22178 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22179 PyObject *resultobj = 0;
22180 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22181 bool result;
22182 void *argp1 = 0 ;
22183 int res1 = 0 ;
22184 PyObject *swig_obj[1] ;
22185
22186 if (!args) SWIG_fail;
22187 swig_obj[0] = args;
22188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22189 if (!SWIG_IsOK(res1)) {
22190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22191 }
22192 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22193 {
22194 PyThreadState* __tstate = wxPyBeginAllowThreads();
22195 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
22196 wxPyEndAllowThreads(__tstate);
22197 if (PyErr_Occurred()) SWIG_fail;
22198 }
22199 {
22200 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22201 }
22202 return resultobj;
22203 fail:
22204 return NULL;
22205 }
22206
22207
22208 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22209 PyObject *resultobj = 0;
22210 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22211 bool result;
22212 void *argp1 = 0 ;
22213 int res1 = 0 ;
22214 PyObject *swig_obj[1] ;
22215
22216 if (!args) SWIG_fail;
22217 swig_obj[0] = args;
22218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22219 if (!SWIG_IsOK(res1)) {
22220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22221 }
22222 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22223 {
22224 PyThreadState* __tstate = wxPyBeginAllowThreads();
22225 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
22226 wxPyEndAllowThreads(__tstate);
22227 if (PyErr_Occurred()) SWIG_fail;
22228 }
22229 {
22230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22231 }
22232 return resultobj;
22233 fail:
22234 return NULL;
22235 }
22236
22237
22238 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22239 PyObject *resultobj = 0;
22240 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22241 bool result;
22242 void *argp1 = 0 ;
22243 int res1 = 0 ;
22244 PyObject *swig_obj[1] ;
22245
22246 if (!args) SWIG_fail;
22247 swig_obj[0] = args;
22248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22249 if (!SWIG_IsOK(res1)) {
22250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22251 }
22252 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22253 {
22254 PyThreadState* __tstate = wxPyBeginAllowThreads();
22255 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22256 wxPyEndAllowThreads(__tstate);
22257 if (PyErr_Occurred()) SWIG_fail;
22258 }
22259 {
22260 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22261 }
22262 return resultobj;
22263 fail:
22264 return NULL;
22265 }
22266
22267
22268 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22269 PyObject *resultobj = 0;
22270 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22271 bool result;
22272 void *argp1 = 0 ;
22273 int res1 = 0 ;
22274 PyObject *swig_obj[1] ;
22275
22276 if (!args) SWIG_fail;
22277 swig_obj[0] = args;
22278 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22279 if (!SWIG_IsOK(res1)) {
22280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22281 }
22282 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22283 {
22284 PyThreadState* __tstate = wxPyBeginAllowThreads();
22285 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22286 wxPyEndAllowThreads(__tstate);
22287 if (PyErr_Occurred()) SWIG_fail;
22288 }
22289 {
22290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22291 }
22292 return resultobj;
22293 fail:
22294 return NULL;
22295 }
22296
22297
22298 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22299 PyObject *resultobj = 0;
22300 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22301 bool result;
22302 void *argp1 = 0 ;
22303 int res1 = 0 ;
22304 PyObject *swig_obj[1] ;
22305
22306 if (!args) SWIG_fail;
22307 swig_obj[0] = args;
22308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22309 if (!SWIG_IsOK(res1)) {
22310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22311 }
22312 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22313 {
22314 PyThreadState* __tstate = wxPyBeginAllowThreads();
22315 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22316 wxPyEndAllowThreads(__tstate);
22317 if (PyErr_Occurred()) SWIG_fail;
22318 }
22319 {
22320 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22321 }
22322 return resultobj;
22323 fail:
22324 return NULL;
22325 }
22326
22327
22328 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22329 PyObject *resultobj = 0;
22330 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22331 int result;
22332 void *argp1 = 0 ;
22333 int res1 = 0 ;
22334 PyObject *swig_obj[1] ;
22335
22336 if (!args) SWIG_fail;
22337 swig_obj[0] = args;
22338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22339 if (!SWIG_IsOK(res1)) {
22340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22341 }
22342 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22343 {
22344 PyThreadState* __tstate = wxPyBeginAllowThreads();
22345 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22346 wxPyEndAllowThreads(__tstate);
22347 if (PyErr_Occurred()) SWIG_fail;
22348 }
22349 resultobj = SWIG_From_int(static_cast< int >(result));
22350 return resultobj;
22351 fail:
22352 return NULL;
22353 }
22354
22355
22356 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22357 PyObject *resultobj = 0;
22358 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22359 int result;
22360 void *argp1 = 0 ;
22361 int res1 = 0 ;
22362 PyObject *swig_obj[1] ;
22363
22364 if (!args) SWIG_fail;
22365 swig_obj[0] = args;
22366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22367 if (!SWIG_IsOK(res1)) {
22368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22369 }
22370 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22371 {
22372 PyThreadState* __tstate = wxPyBeginAllowThreads();
22373 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
22374 wxPyEndAllowThreads(__tstate);
22375 if (PyErr_Occurred()) SWIG_fail;
22376 }
22377 resultobj = SWIG_From_int(static_cast< int >(result));
22378 return resultobj;
22379 fail:
22380 return NULL;
22381 }
22382
22383
22384 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22385 PyObject *resultobj = 0;
22386 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22387 int arg2 ;
22388 void *argp1 = 0 ;
22389 int res1 = 0 ;
22390 int val2 ;
22391 int ecode2 = 0 ;
22392 PyObject * obj0 = 0 ;
22393 PyObject * obj1 = 0 ;
22394 char * kwnames[] = {
22395 (char *) "self",(char *) "uniChar", NULL
22396 };
22397
22398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
22399 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22400 if (!SWIG_IsOK(res1)) {
22401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22402 }
22403 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22404 ecode2 = SWIG_AsVal_int(obj1, &val2);
22405 if (!SWIG_IsOK(ecode2)) {
22406 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
22407 }
22408 arg2 = static_cast< int >(val2);
22409 {
22410 PyThreadState* __tstate = wxPyBeginAllowThreads();
22411 wxKeyEvent_SetUnicodeKey(arg1,arg2);
22412 wxPyEndAllowThreads(__tstate);
22413 if (PyErr_Occurred()) SWIG_fail;
22414 }
22415 resultobj = SWIG_Py_Void();
22416 return resultobj;
22417 fail:
22418 return NULL;
22419 }
22420
22421
22422 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22423 PyObject *resultobj = 0;
22424 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22425 unsigned int result;
22426 void *argp1 = 0 ;
22427 int res1 = 0 ;
22428 PyObject *swig_obj[1] ;
22429
22430 if (!args) SWIG_fail;
22431 swig_obj[0] = args;
22432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22433 if (!SWIG_IsOK(res1)) {
22434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22435 }
22436 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22437 {
22438 PyThreadState* __tstate = wxPyBeginAllowThreads();
22439 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22440 wxPyEndAllowThreads(__tstate);
22441 if (PyErr_Occurred()) SWIG_fail;
22442 }
22443 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22444 return resultobj;
22445 fail:
22446 return NULL;
22447 }
22448
22449
22450 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22451 PyObject *resultobj = 0;
22452 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22453 unsigned int result;
22454 void *argp1 = 0 ;
22455 int res1 = 0 ;
22456 PyObject *swig_obj[1] ;
22457
22458 if (!args) SWIG_fail;
22459 swig_obj[0] = args;
22460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22461 if (!SWIG_IsOK(res1)) {
22462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22463 }
22464 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22465 {
22466 PyThreadState* __tstate = wxPyBeginAllowThreads();
22467 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22468 wxPyEndAllowThreads(__tstate);
22469 if (PyErr_Occurred()) SWIG_fail;
22470 }
22471 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22472 return resultobj;
22473 fail:
22474 return NULL;
22475 }
22476
22477
22478 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22479 PyObject *resultobj = 0;
22480 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22481 wxPoint result;
22482 void *argp1 = 0 ;
22483 int res1 = 0 ;
22484 PyObject *swig_obj[1] ;
22485
22486 if (!args) SWIG_fail;
22487 swig_obj[0] = args;
22488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22489 if (!SWIG_IsOK(res1)) {
22490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22491 }
22492 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22493 {
22494 PyThreadState* __tstate = wxPyBeginAllowThreads();
22495 result = (arg1)->GetPosition();
22496 wxPyEndAllowThreads(__tstate);
22497 if (PyErr_Occurred()) SWIG_fail;
22498 }
22499 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22500 return resultobj;
22501 fail:
22502 return NULL;
22503 }
22504
22505
22506 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22507 PyObject *resultobj = 0;
22508 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22509 long *arg2 = (long *) 0 ;
22510 long *arg3 = (long *) 0 ;
22511 void *argp1 = 0 ;
22512 int res1 = 0 ;
22513 long temp2 ;
22514 int res2 = SWIG_TMPOBJ ;
22515 long temp3 ;
22516 int res3 = SWIG_TMPOBJ ;
22517 PyObject *swig_obj[1] ;
22518
22519 arg2 = &temp2;
22520 arg3 = &temp3;
22521 if (!args) SWIG_fail;
22522 swig_obj[0] = args;
22523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22524 if (!SWIG_IsOK(res1)) {
22525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22526 }
22527 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22528 {
22529 PyThreadState* __tstate = wxPyBeginAllowThreads();
22530 (arg1)->GetPosition(arg2,arg3);
22531 wxPyEndAllowThreads(__tstate);
22532 if (PyErr_Occurred()) SWIG_fail;
22533 }
22534 resultobj = SWIG_Py_Void();
22535 if (SWIG_IsTmpObj(res2)) {
22536 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
22537 } else {
22538 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22539 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
22540 }
22541 if (SWIG_IsTmpObj(res3)) {
22542 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
22543 } else {
22544 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22545 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
22546 }
22547 return resultobj;
22548 fail:
22549 return NULL;
22550 }
22551
22552
22553 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22554 PyObject *resultobj = 0;
22555 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22556 int result;
22557 void *argp1 = 0 ;
22558 int res1 = 0 ;
22559 PyObject *swig_obj[1] ;
22560
22561 if (!args) SWIG_fail;
22562 swig_obj[0] = args;
22563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22564 if (!SWIG_IsOK(res1)) {
22565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22566 }
22567 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22568 {
22569 PyThreadState* __tstate = wxPyBeginAllowThreads();
22570 result = (int)((wxKeyEvent const *)arg1)->GetX();
22571 wxPyEndAllowThreads(__tstate);
22572 if (PyErr_Occurred()) SWIG_fail;
22573 }
22574 resultobj = SWIG_From_int(static_cast< int >(result));
22575 return resultobj;
22576 fail:
22577 return NULL;
22578 }
22579
22580
22581 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22582 PyObject *resultobj = 0;
22583 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22584 int result;
22585 void *argp1 = 0 ;
22586 int res1 = 0 ;
22587 PyObject *swig_obj[1] ;
22588
22589 if (!args) SWIG_fail;
22590 swig_obj[0] = args;
22591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22592 if (!SWIG_IsOK(res1)) {
22593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22594 }
22595 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22596 {
22597 PyThreadState* __tstate = wxPyBeginAllowThreads();
22598 result = (int)((wxKeyEvent const *)arg1)->GetY();
22599 wxPyEndAllowThreads(__tstate);
22600 if (PyErr_Occurred()) SWIG_fail;
22601 }
22602 resultobj = SWIG_From_int(static_cast< int >(result));
22603 return resultobj;
22604 fail:
22605 return NULL;
22606 }
22607
22608
22609 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22610 PyObject *resultobj = 0;
22611 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22612 int arg2 ;
22613 void *argp1 = 0 ;
22614 int res1 = 0 ;
22615 int val2 ;
22616 int ecode2 = 0 ;
22617 PyObject *swig_obj[2] ;
22618
22619 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
22620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22621 if (!SWIG_IsOK(res1)) {
22622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22623 }
22624 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22625 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22626 if (!SWIG_IsOK(ecode2)) {
22627 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
22628 }
22629 arg2 = static_cast< int >(val2);
22630 if (arg1) (arg1)->m_x = arg2;
22631
22632 resultobj = SWIG_Py_Void();
22633 return resultobj;
22634 fail:
22635 return NULL;
22636 }
22637
22638
22639 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22640 PyObject *resultobj = 0;
22641 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22642 int result;
22643 void *argp1 = 0 ;
22644 int res1 = 0 ;
22645 PyObject *swig_obj[1] ;
22646
22647 if (!args) SWIG_fail;
22648 swig_obj[0] = args;
22649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22650 if (!SWIG_IsOK(res1)) {
22651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22652 }
22653 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22654 result = (int) ((arg1)->m_x);
22655 resultobj = SWIG_From_int(static_cast< int >(result));
22656 return resultobj;
22657 fail:
22658 return NULL;
22659 }
22660
22661
22662 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22663 PyObject *resultobj = 0;
22664 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22665 int arg2 ;
22666 void *argp1 = 0 ;
22667 int res1 = 0 ;
22668 int val2 ;
22669 int ecode2 = 0 ;
22670 PyObject *swig_obj[2] ;
22671
22672 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
22673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22674 if (!SWIG_IsOK(res1)) {
22675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22676 }
22677 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22678 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22679 if (!SWIG_IsOK(ecode2)) {
22680 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
22681 }
22682 arg2 = static_cast< int >(val2);
22683 if (arg1) (arg1)->m_y = arg2;
22684
22685 resultobj = SWIG_Py_Void();
22686 return resultobj;
22687 fail:
22688 return NULL;
22689 }
22690
22691
22692 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22693 PyObject *resultobj = 0;
22694 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22695 int result;
22696 void *argp1 = 0 ;
22697 int res1 = 0 ;
22698 PyObject *swig_obj[1] ;
22699
22700 if (!args) SWIG_fail;
22701 swig_obj[0] = args;
22702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22703 if (!SWIG_IsOK(res1)) {
22704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22705 }
22706 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22707 result = (int) ((arg1)->m_y);
22708 resultobj = SWIG_From_int(static_cast< int >(result));
22709 return resultobj;
22710 fail:
22711 return NULL;
22712 }
22713
22714
22715 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22716 PyObject *resultobj = 0;
22717 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22718 long arg2 ;
22719 void *argp1 = 0 ;
22720 int res1 = 0 ;
22721 long val2 ;
22722 int ecode2 = 0 ;
22723 PyObject *swig_obj[2] ;
22724
22725 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
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_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22729 }
22730 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22731 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
22732 if (!SWIG_IsOK(ecode2)) {
22733 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
22734 }
22735 arg2 = static_cast< long >(val2);
22736 if (arg1) (arg1)->m_keyCode = arg2;
22737
22738 resultobj = SWIG_Py_Void();
22739 return resultobj;
22740 fail:
22741 return NULL;
22742 }
22743
22744
22745 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22746 PyObject *resultobj = 0;
22747 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22748 long result;
22749 void *argp1 = 0 ;
22750 int res1 = 0 ;
22751 PyObject *swig_obj[1] ;
22752
22753 if (!args) SWIG_fail;
22754 swig_obj[0] = args;
22755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22756 if (!SWIG_IsOK(res1)) {
22757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22758 }
22759 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22760 result = (long) ((arg1)->m_keyCode);
22761 resultobj = SWIG_From_long(static_cast< long >(result));
22762 return resultobj;
22763 fail:
22764 return NULL;
22765 }
22766
22767
22768 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22769 PyObject *resultobj = 0;
22770 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22771 bool arg2 ;
22772 void *argp1 = 0 ;
22773 int res1 = 0 ;
22774 bool val2 ;
22775 int ecode2 = 0 ;
22776 PyObject *swig_obj[2] ;
22777
22778 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22780 if (!SWIG_IsOK(res1)) {
22781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22782 }
22783 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22784 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22785 if (!SWIG_IsOK(ecode2)) {
22786 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22787 }
22788 arg2 = static_cast< bool >(val2);
22789 if (arg1) (arg1)->m_controlDown = arg2;
22790
22791 resultobj = SWIG_Py_Void();
22792 return resultobj;
22793 fail:
22794 return NULL;
22795 }
22796
22797
22798 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22799 PyObject *resultobj = 0;
22800 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22801 bool result;
22802 void *argp1 = 0 ;
22803 int res1 = 0 ;
22804 PyObject *swig_obj[1] ;
22805
22806 if (!args) SWIG_fail;
22807 swig_obj[0] = args;
22808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22809 if (!SWIG_IsOK(res1)) {
22810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22811 }
22812 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22813 result = (bool) ((arg1)->m_controlDown);
22814 {
22815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22816 }
22817 return resultobj;
22818 fail:
22819 return NULL;
22820 }
22821
22822
22823 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22824 PyObject *resultobj = 0;
22825 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22826 bool arg2 ;
22827 void *argp1 = 0 ;
22828 int res1 = 0 ;
22829 bool val2 ;
22830 int ecode2 = 0 ;
22831 PyObject *swig_obj[2] ;
22832
22833 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22835 if (!SWIG_IsOK(res1)) {
22836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22837 }
22838 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22839 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22840 if (!SWIG_IsOK(ecode2)) {
22841 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22842 }
22843 arg2 = static_cast< bool >(val2);
22844 if (arg1) (arg1)->m_shiftDown = arg2;
22845
22846 resultobj = SWIG_Py_Void();
22847 return resultobj;
22848 fail:
22849 return NULL;
22850 }
22851
22852
22853 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22854 PyObject *resultobj = 0;
22855 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22856 bool result;
22857 void *argp1 = 0 ;
22858 int res1 = 0 ;
22859 PyObject *swig_obj[1] ;
22860
22861 if (!args) SWIG_fail;
22862 swig_obj[0] = args;
22863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22864 if (!SWIG_IsOK(res1)) {
22865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22866 }
22867 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22868 result = (bool) ((arg1)->m_shiftDown);
22869 {
22870 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22871 }
22872 return resultobj;
22873 fail:
22874 return NULL;
22875 }
22876
22877
22878 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22879 PyObject *resultobj = 0;
22880 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22881 bool arg2 ;
22882 void *argp1 = 0 ;
22883 int res1 = 0 ;
22884 bool val2 ;
22885 int ecode2 = 0 ;
22886 PyObject *swig_obj[2] ;
22887
22888 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22890 if (!SWIG_IsOK(res1)) {
22891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22892 }
22893 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22894 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22895 if (!SWIG_IsOK(ecode2)) {
22896 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22897 }
22898 arg2 = static_cast< bool >(val2);
22899 if (arg1) (arg1)->m_altDown = arg2;
22900
22901 resultobj = SWIG_Py_Void();
22902 return resultobj;
22903 fail:
22904 return NULL;
22905 }
22906
22907
22908 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22909 PyObject *resultobj = 0;
22910 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22911 bool result;
22912 void *argp1 = 0 ;
22913 int res1 = 0 ;
22914 PyObject *swig_obj[1] ;
22915
22916 if (!args) SWIG_fail;
22917 swig_obj[0] = args;
22918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22919 if (!SWIG_IsOK(res1)) {
22920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22921 }
22922 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22923 result = (bool) ((arg1)->m_altDown);
22924 {
22925 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22926 }
22927 return resultobj;
22928 fail:
22929 return NULL;
22930 }
22931
22932
22933 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22934 PyObject *resultobj = 0;
22935 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22936 bool arg2 ;
22937 void *argp1 = 0 ;
22938 int res1 = 0 ;
22939 bool val2 ;
22940 int ecode2 = 0 ;
22941 PyObject *swig_obj[2] ;
22942
22943 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
22944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22945 if (!SWIG_IsOK(res1)) {
22946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22947 }
22948 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22949 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22950 if (!SWIG_IsOK(ecode2)) {
22951 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
22952 }
22953 arg2 = static_cast< bool >(val2);
22954 if (arg1) (arg1)->m_metaDown = arg2;
22955
22956 resultobj = SWIG_Py_Void();
22957 return resultobj;
22958 fail:
22959 return NULL;
22960 }
22961
22962
22963 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22964 PyObject *resultobj = 0;
22965 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22966 bool result;
22967 void *argp1 = 0 ;
22968 int res1 = 0 ;
22969 PyObject *swig_obj[1] ;
22970
22971 if (!args) SWIG_fail;
22972 swig_obj[0] = args;
22973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22974 if (!SWIG_IsOK(res1)) {
22975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22976 }
22977 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22978 result = (bool) ((arg1)->m_metaDown);
22979 {
22980 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22981 }
22982 return resultobj;
22983 fail:
22984 return NULL;
22985 }
22986
22987
22988 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22989 PyObject *resultobj = 0;
22990 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22991 bool arg2 ;
22992 void *argp1 = 0 ;
22993 int res1 = 0 ;
22994 bool val2 ;
22995 int ecode2 = 0 ;
22996 PyObject *swig_obj[2] ;
22997
22998 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
22999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23000 if (!SWIG_IsOK(res1)) {
23001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23002 }
23003 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23004 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23005 if (!SWIG_IsOK(ecode2)) {
23006 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
23007 }
23008 arg2 = static_cast< bool >(val2);
23009 if (arg1) (arg1)->m_scanCode = arg2;
23010
23011 resultobj = SWIG_Py_Void();
23012 return resultobj;
23013 fail:
23014 return NULL;
23015 }
23016
23017
23018 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23019 PyObject *resultobj = 0;
23020 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23021 bool result;
23022 void *argp1 = 0 ;
23023 int res1 = 0 ;
23024 PyObject *swig_obj[1] ;
23025
23026 if (!args) SWIG_fail;
23027 swig_obj[0] = args;
23028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23029 if (!SWIG_IsOK(res1)) {
23030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23031 }
23032 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23033 result = (bool) ((arg1)->m_scanCode);
23034 {
23035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23036 }
23037 return resultobj;
23038 fail:
23039 return NULL;
23040 }
23041
23042
23043 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23044 PyObject *resultobj = 0;
23045 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23046 unsigned int arg2 ;
23047 void *argp1 = 0 ;
23048 int res1 = 0 ;
23049 unsigned int val2 ;
23050 int ecode2 = 0 ;
23051 PyObject *swig_obj[2] ;
23052
23053 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
23054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23055 if (!SWIG_IsOK(res1)) {
23056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23057 }
23058 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23059 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
23060 if (!SWIG_IsOK(ecode2)) {
23061 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
23062 }
23063 arg2 = static_cast< unsigned int >(val2);
23064 if (arg1) (arg1)->m_rawCode = arg2;
23065
23066 resultobj = SWIG_Py_Void();
23067 return resultobj;
23068 fail:
23069 return NULL;
23070 }
23071
23072
23073 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23074 PyObject *resultobj = 0;
23075 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23076 unsigned int result;
23077 void *argp1 = 0 ;
23078 int res1 = 0 ;
23079 PyObject *swig_obj[1] ;
23080
23081 if (!args) SWIG_fail;
23082 swig_obj[0] = args;
23083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23084 if (!SWIG_IsOK(res1)) {
23085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23086 }
23087 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23088 result = (unsigned int) ((arg1)->m_rawCode);
23089 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23090 return resultobj;
23091 fail:
23092 return NULL;
23093 }
23094
23095
23096 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23097 PyObject *resultobj = 0;
23098 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23099 unsigned int arg2 ;
23100 void *argp1 = 0 ;
23101 int res1 = 0 ;
23102 unsigned int val2 ;
23103 int ecode2 = 0 ;
23104 PyObject *swig_obj[2] ;
23105
23106 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
23107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23108 if (!SWIG_IsOK(res1)) {
23109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23110 }
23111 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23112 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
23113 if (!SWIG_IsOK(ecode2)) {
23114 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
23115 }
23116 arg2 = static_cast< unsigned int >(val2);
23117 if (arg1) (arg1)->m_rawFlags = arg2;
23118
23119 resultobj = SWIG_Py_Void();
23120 return resultobj;
23121 fail:
23122 return NULL;
23123 }
23124
23125
23126 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23127 PyObject *resultobj = 0;
23128 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23129 unsigned int result;
23130 void *argp1 = 0 ;
23131 int res1 = 0 ;
23132 PyObject *swig_obj[1] ;
23133
23134 if (!args) SWIG_fail;
23135 swig_obj[0] = args;
23136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23137 if (!SWIG_IsOK(res1)) {
23138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23139 }
23140 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23141 result = (unsigned int) ((arg1)->m_rawFlags);
23142 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23143 return resultobj;
23144 fail:
23145 return NULL;
23146 }
23147
23148
23149 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23150 PyObject *obj;
23151 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23152 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
23153 return SWIG_Py_Void();
23154 }
23155
23156 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23157 return SWIG_Python_InitShadowInstance(args);
23158 }
23159
23160 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23161 PyObject *resultobj = 0;
23162 wxSize const &arg1_defvalue = wxDefaultSize ;
23163 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
23164 int arg2 = (int) 0 ;
23165 wxSizeEvent *result = 0 ;
23166 wxSize temp1 ;
23167 int val2 ;
23168 int ecode2 = 0 ;
23169 PyObject * obj0 = 0 ;
23170 PyObject * obj1 = 0 ;
23171 char * kwnames[] = {
23172 (char *) "sz",(char *) "winid", NULL
23173 };
23174
23175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23176 if (obj0) {
23177 {
23178 arg1 = &temp1;
23179 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
23180 }
23181 }
23182 if (obj1) {
23183 ecode2 = SWIG_AsVal_int(obj1, &val2);
23184 if (!SWIG_IsOK(ecode2)) {
23185 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
23186 }
23187 arg2 = static_cast< int >(val2);
23188 }
23189 {
23190 PyThreadState* __tstate = wxPyBeginAllowThreads();
23191 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
23192 wxPyEndAllowThreads(__tstate);
23193 if (PyErr_Occurred()) SWIG_fail;
23194 }
23195 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
23196 return resultobj;
23197 fail:
23198 return NULL;
23199 }
23200
23201
23202 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23203 PyObject *resultobj = 0;
23204 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23205 wxSize result;
23206 void *argp1 = 0 ;
23207 int res1 = 0 ;
23208 PyObject *swig_obj[1] ;
23209
23210 if (!args) SWIG_fail;
23211 swig_obj[0] = args;
23212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23213 if (!SWIG_IsOK(res1)) {
23214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23215 }
23216 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23217 {
23218 PyThreadState* __tstate = wxPyBeginAllowThreads();
23219 result = ((wxSizeEvent const *)arg1)->GetSize();
23220 wxPyEndAllowThreads(__tstate);
23221 if (PyErr_Occurred()) SWIG_fail;
23222 }
23223 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
23224 return resultobj;
23225 fail:
23226 return NULL;
23227 }
23228
23229
23230 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23231 PyObject *resultobj = 0;
23232 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23233 wxRect result;
23234 void *argp1 = 0 ;
23235 int res1 = 0 ;
23236 PyObject *swig_obj[1] ;
23237
23238 if (!args) SWIG_fail;
23239 swig_obj[0] = args;
23240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23241 if (!SWIG_IsOK(res1)) {
23242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23243 }
23244 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23245 {
23246 PyThreadState* __tstate = wxPyBeginAllowThreads();
23247 result = ((wxSizeEvent const *)arg1)->GetRect();
23248 wxPyEndAllowThreads(__tstate);
23249 if (PyErr_Occurred()) SWIG_fail;
23250 }
23251 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23252 return resultobj;
23253 fail:
23254 return NULL;
23255 }
23256
23257
23258 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23259 PyObject *resultobj = 0;
23260 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23261 wxRect arg2 ;
23262 void *argp1 = 0 ;
23263 int res1 = 0 ;
23264 void *argp2 ;
23265 int res2 = 0 ;
23266 PyObject * obj0 = 0 ;
23267 PyObject * obj1 = 0 ;
23268 char * kwnames[] = {
23269 (char *) "self",(char *) "rect", NULL
23270 };
23271
23272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23274 if (!SWIG_IsOK(res1)) {
23275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23276 }
23277 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23278 {
23279 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
23280 if (!SWIG_IsOK(res2)) {
23281 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23282 }
23283 if (!argp2) {
23284 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23285 } else {
23286 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
23287 arg2 = *temp;
23288 if (SWIG_IsNewObj(res2)) delete temp;
23289 }
23290 }
23291 {
23292 PyThreadState* __tstate = wxPyBeginAllowThreads();
23293 (arg1)->SetRect(arg2);
23294 wxPyEndAllowThreads(__tstate);
23295 if (PyErr_Occurred()) SWIG_fail;
23296 }
23297 resultobj = SWIG_Py_Void();
23298 return resultobj;
23299 fail:
23300 return NULL;
23301 }
23302
23303
23304 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23305 PyObject *resultobj = 0;
23306 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23307 wxSize arg2 ;
23308 void *argp1 = 0 ;
23309 int res1 = 0 ;
23310 void *argp2 ;
23311 int res2 = 0 ;
23312 PyObject * obj0 = 0 ;
23313 PyObject * obj1 = 0 ;
23314 char * kwnames[] = {
23315 (char *) "self",(char *) "size", NULL
23316 };
23317
23318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23320 if (!SWIG_IsOK(res1)) {
23321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23322 }
23323 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23324 {
23325 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23326 if (!SWIG_IsOK(res2)) {
23327 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23328 }
23329 if (!argp2) {
23330 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23331 } else {
23332 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23333 arg2 = *temp;
23334 if (SWIG_IsNewObj(res2)) delete temp;
23335 }
23336 }
23337 {
23338 PyThreadState* __tstate = wxPyBeginAllowThreads();
23339 wxSizeEvent_SetSize(arg1,arg2);
23340 wxPyEndAllowThreads(__tstate);
23341 if (PyErr_Occurred()) SWIG_fail;
23342 }
23343 resultobj = SWIG_Py_Void();
23344 return resultobj;
23345 fail:
23346 return NULL;
23347 }
23348
23349
23350 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23351 PyObject *resultobj = 0;
23352 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23353 wxSize *arg2 = (wxSize *) 0 ;
23354 void *argp1 = 0 ;
23355 int res1 = 0 ;
23356 void *argp2 = 0 ;
23357 int res2 = 0 ;
23358 PyObject *swig_obj[2] ;
23359
23360 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
23361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23362 if (!SWIG_IsOK(res1)) {
23363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23364 }
23365 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23366 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23367 if (!SWIG_IsOK(res2)) {
23368 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23369 }
23370 arg2 = reinterpret_cast< wxSize * >(argp2);
23371 if (arg1) (arg1)->m_size = *arg2;
23372
23373 resultobj = SWIG_Py_Void();
23374 return resultobj;
23375 fail:
23376 return NULL;
23377 }
23378
23379
23380 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23381 PyObject *resultobj = 0;
23382 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23383 wxSize *result = 0 ;
23384 void *argp1 = 0 ;
23385 int res1 = 0 ;
23386 PyObject *swig_obj[1] ;
23387
23388 if (!args) SWIG_fail;
23389 swig_obj[0] = args;
23390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23391 if (!SWIG_IsOK(res1)) {
23392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23393 }
23394 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23395 result = (wxSize *)& ((arg1)->m_size);
23396 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23397 return resultobj;
23398 fail:
23399 return NULL;
23400 }
23401
23402
23403 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23404 PyObject *resultobj = 0;
23405 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23406 wxRect *arg2 = (wxRect *) 0 ;
23407 void *argp1 = 0 ;
23408 int res1 = 0 ;
23409 void *argp2 = 0 ;
23410 int res2 = 0 ;
23411 PyObject *swig_obj[2] ;
23412
23413 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23415 if (!SWIG_IsOK(res1)) {
23416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23417 }
23418 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23419 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23420 if (!SWIG_IsOK(res2)) {
23421 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23422 }
23423 arg2 = reinterpret_cast< wxRect * >(argp2);
23424 if (arg1) (arg1)->m_rect = *arg2;
23425
23426 resultobj = SWIG_Py_Void();
23427 return resultobj;
23428 fail:
23429 return NULL;
23430 }
23431
23432
23433 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23434 PyObject *resultobj = 0;
23435 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23436 wxRect *result = 0 ;
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_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23446 }
23447 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23448 result = (wxRect *)& ((arg1)->m_rect);
23449 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23450 return resultobj;
23451 fail:
23452 return NULL;
23453 }
23454
23455
23456 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23457 PyObject *obj;
23458 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23459 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23460 return SWIG_Py_Void();
23461 }
23462
23463 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23464 return SWIG_Python_InitShadowInstance(args);
23465 }
23466
23467 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23468 PyObject *resultobj = 0;
23469 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23470 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23471 int arg2 = (int) 0 ;
23472 wxMoveEvent *result = 0 ;
23473 wxPoint temp1 ;
23474 int val2 ;
23475 int ecode2 = 0 ;
23476 PyObject * obj0 = 0 ;
23477 PyObject * obj1 = 0 ;
23478 char * kwnames[] = {
23479 (char *) "pos",(char *) "winid", NULL
23480 };
23481
23482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23483 if (obj0) {
23484 {
23485 arg1 = &temp1;
23486 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
23487 }
23488 }
23489 if (obj1) {
23490 ecode2 = SWIG_AsVal_int(obj1, &val2);
23491 if (!SWIG_IsOK(ecode2)) {
23492 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
23493 }
23494 arg2 = static_cast< int >(val2);
23495 }
23496 {
23497 PyThreadState* __tstate = wxPyBeginAllowThreads();
23498 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
23499 wxPyEndAllowThreads(__tstate);
23500 if (PyErr_Occurred()) SWIG_fail;
23501 }
23502 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
23503 return resultobj;
23504 fail:
23505 return NULL;
23506 }
23507
23508
23509 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23510 PyObject *resultobj = 0;
23511 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23512 wxPoint result;
23513 void *argp1 = 0 ;
23514 int res1 = 0 ;
23515 PyObject *swig_obj[1] ;
23516
23517 if (!args) SWIG_fail;
23518 swig_obj[0] = args;
23519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23520 if (!SWIG_IsOK(res1)) {
23521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23522 }
23523 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23524 {
23525 PyThreadState* __tstate = wxPyBeginAllowThreads();
23526 result = ((wxMoveEvent const *)arg1)->GetPosition();
23527 wxPyEndAllowThreads(__tstate);
23528 if (PyErr_Occurred()) SWIG_fail;
23529 }
23530 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23531 return resultobj;
23532 fail:
23533 return NULL;
23534 }
23535
23536
23537 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23538 PyObject *resultobj = 0;
23539 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23540 wxRect result;
23541 void *argp1 = 0 ;
23542 int res1 = 0 ;
23543 PyObject *swig_obj[1] ;
23544
23545 if (!args) SWIG_fail;
23546 swig_obj[0] = args;
23547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23548 if (!SWIG_IsOK(res1)) {
23549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23550 }
23551 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23552 {
23553 PyThreadState* __tstate = wxPyBeginAllowThreads();
23554 result = ((wxMoveEvent const *)arg1)->GetRect();
23555 wxPyEndAllowThreads(__tstate);
23556 if (PyErr_Occurred()) SWIG_fail;
23557 }
23558 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23559 return resultobj;
23560 fail:
23561 return NULL;
23562 }
23563
23564
23565 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23566 PyObject *resultobj = 0;
23567 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23568 wxRect *arg2 = 0 ;
23569 void *argp1 = 0 ;
23570 int res1 = 0 ;
23571 wxRect temp2 ;
23572 PyObject * obj0 = 0 ;
23573 PyObject * obj1 = 0 ;
23574 char * kwnames[] = {
23575 (char *) "self",(char *) "rect", NULL
23576 };
23577
23578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23579 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23580 if (!SWIG_IsOK(res1)) {
23581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23582 }
23583 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23584 {
23585 arg2 = &temp2;
23586 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23587 }
23588 {
23589 PyThreadState* __tstate = wxPyBeginAllowThreads();
23590 (arg1)->SetRect((wxRect const &)*arg2);
23591 wxPyEndAllowThreads(__tstate);
23592 if (PyErr_Occurred()) SWIG_fail;
23593 }
23594 resultobj = SWIG_Py_Void();
23595 return resultobj;
23596 fail:
23597 return NULL;
23598 }
23599
23600
23601 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23602 PyObject *resultobj = 0;
23603 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23604 wxPoint *arg2 = 0 ;
23605 void *argp1 = 0 ;
23606 int res1 = 0 ;
23607 wxPoint temp2 ;
23608 PyObject * obj0 = 0 ;
23609 PyObject * obj1 = 0 ;
23610 char * kwnames[] = {
23611 (char *) "self",(char *) "pos", NULL
23612 };
23613
23614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23616 if (!SWIG_IsOK(res1)) {
23617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23618 }
23619 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23620 {
23621 arg2 = &temp2;
23622 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23623 }
23624 {
23625 PyThreadState* __tstate = wxPyBeginAllowThreads();
23626 (arg1)->SetPosition((wxPoint const &)*arg2);
23627 wxPyEndAllowThreads(__tstate);
23628 if (PyErr_Occurred()) SWIG_fail;
23629 }
23630 resultobj = SWIG_Py_Void();
23631 return resultobj;
23632 fail:
23633 return NULL;
23634 }
23635
23636
23637 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23638 PyObject *obj;
23639 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23640 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
23641 return SWIG_Py_Void();
23642 }
23643
23644 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23645 return SWIG_Python_InitShadowInstance(args);
23646 }
23647
23648 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23649 PyObject *resultobj = 0;
23650 int arg1 = (int) 0 ;
23651 wxPaintEvent *result = 0 ;
23652 int val1 ;
23653 int ecode1 = 0 ;
23654 PyObject * obj0 = 0 ;
23655 char * kwnames[] = {
23656 (char *) "Id", NULL
23657 };
23658
23659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
23660 if (obj0) {
23661 ecode1 = SWIG_AsVal_int(obj0, &val1);
23662 if (!SWIG_IsOK(ecode1)) {
23663 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
23664 }
23665 arg1 = static_cast< int >(val1);
23666 }
23667 {
23668 PyThreadState* __tstate = wxPyBeginAllowThreads();
23669 result = (wxPaintEvent *)new wxPaintEvent(arg1);
23670 wxPyEndAllowThreads(__tstate);
23671 if (PyErr_Occurred()) SWIG_fail;
23672 }
23673 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
23674 return resultobj;
23675 fail:
23676 return NULL;
23677 }
23678
23679
23680 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23681 PyObject *obj;
23682 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23683 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
23684 return SWIG_Py_Void();
23685 }
23686
23687 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23688 return SWIG_Python_InitShadowInstance(args);
23689 }
23690
23691 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23692 PyObject *resultobj = 0;
23693 int arg1 = (int) 0 ;
23694 wxNcPaintEvent *result = 0 ;
23695 int val1 ;
23696 int ecode1 = 0 ;
23697 PyObject * obj0 = 0 ;
23698 char * kwnames[] = {
23699 (char *) "winid", NULL
23700 };
23701
23702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
23703 if (obj0) {
23704 ecode1 = SWIG_AsVal_int(obj0, &val1);
23705 if (!SWIG_IsOK(ecode1)) {
23706 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
23707 }
23708 arg1 = static_cast< int >(val1);
23709 }
23710 {
23711 PyThreadState* __tstate = wxPyBeginAllowThreads();
23712 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
23713 wxPyEndAllowThreads(__tstate);
23714 if (PyErr_Occurred()) SWIG_fail;
23715 }
23716 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
23717 return resultobj;
23718 fail:
23719 return NULL;
23720 }
23721
23722
23723 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23724 PyObject *obj;
23725 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23726 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
23727 return SWIG_Py_Void();
23728 }
23729
23730 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23731 return SWIG_Python_InitShadowInstance(args);
23732 }
23733
23734 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23735 PyObject *resultobj = 0;
23736 int arg1 = (int) 0 ;
23737 wxDC *arg2 = (wxDC *) NULL ;
23738 wxEraseEvent *result = 0 ;
23739 int val1 ;
23740 int ecode1 = 0 ;
23741 void *argp2 = 0 ;
23742 int res2 = 0 ;
23743 PyObject * obj0 = 0 ;
23744 PyObject * obj1 = 0 ;
23745 char * kwnames[] = {
23746 (char *) "Id",(char *) "dc", NULL
23747 };
23748
23749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23750 if (obj0) {
23751 ecode1 = SWIG_AsVal_int(obj0, &val1);
23752 if (!SWIG_IsOK(ecode1)) {
23753 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
23754 }
23755 arg1 = static_cast< int >(val1);
23756 }
23757 if (obj1) {
23758 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
23759 if (!SWIG_IsOK(res2)) {
23760 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
23761 }
23762 arg2 = reinterpret_cast< wxDC * >(argp2);
23763 }
23764 {
23765 PyThreadState* __tstate = wxPyBeginAllowThreads();
23766 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
23767 wxPyEndAllowThreads(__tstate);
23768 if (PyErr_Occurred()) SWIG_fail;
23769 }
23770 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
23771 return resultobj;
23772 fail:
23773 return NULL;
23774 }
23775
23776
23777 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23778 PyObject *resultobj = 0;
23779 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
23780 wxDC *result = 0 ;
23781 void *argp1 = 0 ;
23782 int res1 = 0 ;
23783 PyObject *swig_obj[1] ;
23784
23785 if (!args) SWIG_fail;
23786 swig_obj[0] = args;
23787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
23788 if (!SWIG_IsOK(res1)) {
23789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
23790 }
23791 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
23792 {
23793 PyThreadState* __tstate = wxPyBeginAllowThreads();
23794 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
23795 wxPyEndAllowThreads(__tstate);
23796 if (PyErr_Occurred()) SWIG_fail;
23797 }
23798 {
23799 resultobj = wxPyMake_wxObject(result, (bool)0);
23800 }
23801 return resultobj;
23802 fail:
23803 return NULL;
23804 }
23805
23806
23807 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23808 PyObject *obj;
23809 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23810 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
23811 return SWIG_Py_Void();
23812 }
23813
23814 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23815 return SWIG_Python_InitShadowInstance(args);
23816 }
23817
23818 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23819 PyObject *resultobj = 0;
23820 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23821 int arg2 = (int) 0 ;
23822 wxFocusEvent *result = 0 ;
23823 int val1 ;
23824 int ecode1 = 0 ;
23825 int val2 ;
23826 int ecode2 = 0 ;
23827 PyObject * obj0 = 0 ;
23828 PyObject * obj1 = 0 ;
23829 char * kwnames[] = {
23830 (char *) "type",(char *) "winid", NULL
23831 };
23832
23833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23834 if (obj0) {
23835 ecode1 = SWIG_AsVal_int(obj0, &val1);
23836 if (!SWIG_IsOK(ecode1)) {
23837 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23838 }
23839 arg1 = static_cast< wxEventType >(val1);
23840 }
23841 if (obj1) {
23842 ecode2 = SWIG_AsVal_int(obj1, &val2);
23843 if (!SWIG_IsOK(ecode2)) {
23844 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
23845 }
23846 arg2 = static_cast< int >(val2);
23847 }
23848 {
23849 PyThreadState* __tstate = wxPyBeginAllowThreads();
23850 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
23851 wxPyEndAllowThreads(__tstate);
23852 if (PyErr_Occurred()) SWIG_fail;
23853 }
23854 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
23855 return resultobj;
23856 fail:
23857 return NULL;
23858 }
23859
23860
23861 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23862 PyObject *resultobj = 0;
23863 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23864 wxWindow *result = 0 ;
23865 void *argp1 = 0 ;
23866 int res1 = 0 ;
23867 PyObject *swig_obj[1] ;
23868
23869 if (!args) SWIG_fail;
23870 swig_obj[0] = args;
23871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23872 if (!SWIG_IsOK(res1)) {
23873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
23874 }
23875 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23876 {
23877 PyThreadState* __tstate = wxPyBeginAllowThreads();
23878 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
23879 wxPyEndAllowThreads(__tstate);
23880 if (PyErr_Occurred()) SWIG_fail;
23881 }
23882 {
23883 resultobj = wxPyMake_wxObject(result, (bool)0);
23884 }
23885 return resultobj;
23886 fail:
23887 return NULL;
23888 }
23889
23890
23891 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23892 PyObject *resultobj = 0;
23893 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23894 wxWindow *arg2 = (wxWindow *) 0 ;
23895 void *argp1 = 0 ;
23896 int res1 = 0 ;
23897 void *argp2 = 0 ;
23898 int res2 = 0 ;
23899 PyObject * obj0 = 0 ;
23900 PyObject * obj1 = 0 ;
23901 char * kwnames[] = {
23902 (char *) "self",(char *) "win", NULL
23903 };
23904
23905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
23906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23907 if (!SWIG_IsOK(res1)) {
23908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
23909 }
23910 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23911 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
23912 if (!SWIG_IsOK(res2)) {
23913 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
23914 }
23915 arg2 = reinterpret_cast< wxWindow * >(argp2);
23916 {
23917 PyThreadState* __tstate = wxPyBeginAllowThreads();
23918 (arg1)->SetWindow(arg2);
23919 wxPyEndAllowThreads(__tstate);
23920 if (PyErr_Occurred()) SWIG_fail;
23921 }
23922 resultobj = SWIG_Py_Void();
23923 return resultobj;
23924 fail:
23925 return NULL;
23926 }
23927
23928
23929 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23930 PyObject *obj;
23931 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23932 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
23933 return SWIG_Py_Void();
23934 }
23935
23936 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23937 return SWIG_Python_InitShadowInstance(args);
23938 }
23939
23940 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23941 PyObject *resultobj = 0;
23942 wxWindow *arg1 = (wxWindow *) NULL ;
23943 wxChildFocusEvent *result = 0 ;
23944 void *argp1 = 0 ;
23945 int res1 = 0 ;
23946 PyObject * obj0 = 0 ;
23947 char * kwnames[] = {
23948 (char *) "win", NULL
23949 };
23950
23951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
23952 if (obj0) {
23953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
23954 if (!SWIG_IsOK(res1)) {
23955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
23956 }
23957 arg1 = reinterpret_cast< wxWindow * >(argp1);
23958 }
23959 {
23960 PyThreadState* __tstate = wxPyBeginAllowThreads();
23961 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
23962 wxPyEndAllowThreads(__tstate);
23963 if (PyErr_Occurred()) SWIG_fail;
23964 }
23965 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
23966 return resultobj;
23967 fail:
23968 return NULL;
23969 }
23970
23971
23972 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23973 PyObject *resultobj = 0;
23974 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
23975 wxWindow *result = 0 ;
23976 void *argp1 = 0 ;
23977 int res1 = 0 ;
23978 PyObject *swig_obj[1] ;
23979
23980 if (!args) SWIG_fail;
23981 swig_obj[0] = args;
23982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
23983 if (!SWIG_IsOK(res1)) {
23984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
23985 }
23986 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
23987 {
23988 PyThreadState* __tstate = wxPyBeginAllowThreads();
23989 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
23990 wxPyEndAllowThreads(__tstate);
23991 if (PyErr_Occurred()) SWIG_fail;
23992 }
23993 {
23994 resultobj = wxPyMake_wxObject(result, (bool)0);
23995 }
23996 return resultobj;
23997 fail:
23998 return NULL;
23999 }
24000
24001
24002 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24003 PyObject *obj;
24004 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24005 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
24006 return SWIG_Py_Void();
24007 }
24008
24009 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24010 return SWIG_Python_InitShadowInstance(args);
24011 }
24012
24013 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24014 PyObject *resultobj = 0;
24015 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24016 bool arg2 = (bool) true ;
24017 int arg3 = (int) 0 ;
24018 wxActivateEvent *result = 0 ;
24019 int val1 ;
24020 int ecode1 = 0 ;
24021 bool val2 ;
24022 int ecode2 = 0 ;
24023 int val3 ;
24024 int ecode3 = 0 ;
24025 PyObject * obj0 = 0 ;
24026 PyObject * obj1 = 0 ;
24027 PyObject * obj2 = 0 ;
24028 char * kwnames[] = {
24029 (char *) "type",(char *) "active",(char *) "Id", NULL
24030 };
24031
24032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24033 if (obj0) {
24034 ecode1 = SWIG_AsVal_int(obj0, &val1);
24035 if (!SWIG_IsOK(ecode1)) {
24036 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24037 }
24038 arg1 = static_cast< wxEventType >(val1);
24039 }
24040 if (obj1) {
24041 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24042 if (!SWIG_IsOK(ecode2)) {
24043 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
24044 }
24045 arg2 = static_cast< bool >(val2);
24046 }
24047 if (obj2) {
24048 ecode3 = SWIG_AsVal_int(obj2, &val3);
24049 if (!SWIG_IsOK(ecode3)) {
24050 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
24051 }
24052 arg3 = static_cast< int >(val3);
24053 }
24054 {
24055 PyThreadState* __tstate = wxPyBeginAllowThreads();
24056 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
24057 wxPyEndAllowThreads(__tstate);
24058 if (PyErr_Occurred()) SWIG_fail;
24059 }
24060 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
24061 return resultobj;
24062 fail:
24063 return NULL;
24064 }
24065
24066
24067 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24068 PyObject *resultobj = 0;
24069 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
24070 bool result;
24071 void *argp1 = 0 ;
24072 int res1 = 0 ;
24073 PyObject *swig_obj[1] ;
24074
24075 if (!args) SWIG_fail;
24076 swig_obj[0] = args;
24077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
24078 if (!SWIG_IsOK(res1)) {
24079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
24080 }
24081 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
24082 {
24083 PyThreadState* __tstate = wxPyBeginAllowThreads();
24084 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
24085 wxPyEndAllowThreads(__tstate);
24086 if (PyErr_Occurred()) SWIG_fail;
24087 }
24088 {
24089 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24090 }
24091 return resultobj;
24092 fail:
24093 return NULL;
24094 }
24095
24096
24097 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24098 PyObject *obj;
24099 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24100 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
24101 return SWIG_Py_Void();
24102 }
24103
24104 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24105 return SWIG_Python_InitShadowInstance(args);
24106 }
24107
24108 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24109 PyObject *resultobj = 0;
24110 int arg1 = (int) 0 ;
24111 wxInitDialogEvent *result = 0 ;
24112 int val1 ;
24113 int ecode1 = 0 ;
24114 PyObject * obj0 = 0 ;
24115 char * kwnames[] = {
24116 (char *) "Id", NULL
24117 };
24118
24119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
24120 if (obj0) {
24121 ecode1 = SWIG_AsVal_int(obj0, &val1);
24122 if (!SWIG_IsOK(ecode1)) {
24123 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
24124 }
24125 arg1 = static_cast< int >(val1);
24126 }
24127 {
24128 PyThreadState* __tstate = wxPyBeginAllowThreads();
24129 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
24130 wxPyEndAllowThreads(__tstate);
24131 if (PyErr_Occurred()) SWIG_fail;
24132 }
24133 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
24134 return resultobj;
24135 fail:
24136 return NULL;
24137 }
24138
24139
24140 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24141 PyObject *obj;
24142 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24143 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
24144 return SWIG_Py_Void();
24145 }
24146
24147 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24148 return SWIG_Python_InitShadowInstance(args);
24149 }
24150
24151 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24152 PyObject *resultobj = 0;
24153 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24154 int arg2 = (int) 0 ;
24155 wxMenu *arg3 = (wxMenu *) NULL ;
24156 wxMenuEvent *result = 0 ;
24157 int val1 ;
24158 int ecode1 = 0 ;
24159 int val2 ;
24160 int ecode2 = 0 ;
24161 void *argp3 = 0 ;
24162 int res3 = 0 ;
24163 PyObject * obj0 = 0 ;
24164 PyObject * obj1 = 0 ;
24165 PyObject * obj2 = 0 ;
24166 char * kwnames[] = {
24167 (char *) "type",(char *) "winid",(char *) "menu", NULL
24168 };
24169
24170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24171 if (obj0) {
24172 ecode1 = SWIG_AsVal_int(obj0, &val1);
24173 if (!SWIG_IsOK(ecode1)) {
24174 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24175 }
24176 arg1 = static_cast< wxEventType >(val1);
24177 }
24178 if (obj1) {
24179 ecode2 = SWIG_AsVal_int(obj1, &val2);
24180 if (!SWIG_IsOK(ecode2)) {
24181 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
24182 }
24183 arg2 = static_cast< int >(val2);
24184 }
24185 if (obj2) {
24186 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
24187 if (!SWIG_IsOK(res3)) {
24188 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
24189 }
24190 arg3 = reinterpret_cast< wxMenu * >(argp3);
24191 }
24192 {
24193 PyThreadState* __tstate = wxPyBeginAllowThreads();
24194 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
24195 wxPyEndAllowThreads(__tstate);
24196 if (PyErr_Occurred()) SWIG_fail;
24197 }
24198 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
24199 return resultobj;
24200 fail:
24201 return NULL;
24202 }
24203
24204
24205 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24206 PyObject *resultobj = 0;
24207 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24208 int result;
24209 void *argp1 = 0 ;
24210 int res1 = 0 ;
24211 PyObject *swig_obj[1] ;
24212
24213 if (!args) SWIG_fail;
24214 swig_obj[0] = args;
24215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24216 if (!SWIG_IsOK(res1)) {
24217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24218 }
24219 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24220 {
24221 PyThreadState* __tstate = wxPyBeginAllowThreads();
24222 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
24223 wxPyEndAllowThreads(__tstate);
24224 if (PyErr_Occurred()) SWIG_fail;
24225 }
24226 resultobj = SWIG_From_int(static_cast< int >(result));
24227 return resultobj;
24228 fail:
24229 return NULL;
24230 }
24231
24232
24233 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24234 PyObject *resultobj = 0;
24235 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24236 bool result;
24237 void *argp1 = 0 ;
24238 int res1 = 0 ;
24239 PyObject *swig_obj[1] ;
24240
24241 if (!args) SWIG_fail;
24242 swig_obj[0] = args;
24243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24244 if (!SWIG_IsOK(res1)) {
24245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24246 }
24247 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24248 {
24249 PyThreadState* __tstate = wxPyBeginAllowThreads();
24250 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
24251 wxPyEndAllowThreads(__tstate);
24252 if (PyErr_Occurred()) SWIG_fail;
24253 }
24254 {
24255 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24256 }
24257 return resultobj;
24258 fail:
24259 return NULL;
24260 }
24261
24262
24263 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24264 PyObject *resultobj = 0;
24265 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24266 wxMenu *result = 0 ;
24267 void *argp1 = 0 ;
24268 int res1 = 0 ;
24269 PyObject *swig_obj[1] ;
24270
24271 if (!args) SWIG_fail;
24272 swig_obj[0] = args;
24273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24274 if (!SWIG_IsOK(res1)) {
24275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24276 }
24277 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24278 {
24279 PyThreadState* __tstate = wxPyBeginAllowThreads();
24280 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
24281 wxPyEndAllowThreads(__tstate);
24282 if (PyErr_Occurred()) SWIG_fail;
24283 }
24284 {
24285 resultobj = wxPyMake_wxObject(result, (bool)0);
24286 }
24287 return resultobj;
24288 fail:
24289 return NULL;
24290 }
24291
24292
24293 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24294 PyObject *obj;
24295 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24296 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24297 return SWIG_Py_Void();
24298 }
24299
24300 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24301 return SWIG_Python_InitShadowInstance(args);
24302 }
24303
24304 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24305 PyObject *resultobj = 0;
24306 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24307 int arg2 = (int) 0 ;
24308 wxCloseEvent *result = 0 ;
24309 int val1 ;
24310 int ecode1 = 0 ;
24311 int val2 ;
24312 int ecode2 = 0 ;
24313 PyObject * obj0 = 0 ;
24314 PyObject * obj1 = 0 ;
24315 char * kwnames[] = {
24316 (char *) "type",(char *) "winid", NULL
24317 };
24318
24319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24320 if (obj0) {
24321 ecode1 = SWIG_AsVal_int(obj0, &val1);
24322 if (!SWIG_IsOK(ecode1)) {
24323 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24324 }
24325 arg1 = static_cast< wxEventType >(val1);
24326 }
24327 if (obj1) {
24328 ecode2 = SWIG_AsVal_int(obj1, &val2);
24329 if (!SWIG_IsOK(ecode2)) {
24330 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24331 }
24332 arg2 = static_cast< int >(val2);
24333 }
24334 {
24335 PyThreadState* __tstate = wxPyBeginAllowThreads();
24336 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
24337 wxPyEndAllowThreads(__tstate);
24338 if (PyErr_Occurred()) SWIG_fail;
24339 }
24340 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
24341 return resultobj;
24342 fail:
24343 return NULL;
24344 }
24345
24346
24347 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24348 PyObject *resultobj = 0;
24349 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24350 bool arg2 ;
24351 void *argp1 = 0 ;
24352 int res1 = 0 ;
24353 bool val2 ;
24354 int ecode2 = 0 ;
24355 PyObject * obj0 = 0 ;
24356 PyObject * obj1 = 0 ;
24357 char * kwnames[] = {
24358 (char *) "self",(char *) "logOff", NULL
24359 };
24360
24361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
24362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24363 if (!SWIG_IsOK(res1)) {
24364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24365 }
24366 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24367 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24368 if (!SWIG_IsOK(ecode2)) {
24369 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24370 }
24371 arg2 = static_cast< bool >(val2);
24372 {
24373 PyThreadState* __tstate = wxPyBeginAllowThreads();
24374 (arg1)->SetLoggingOff(arg2);
24375 wxPyEndAllowThreads(__tstate);
24376 if (PyErr_Occurred()) SWIG_fail;
24377 }
24378 resultobj = SWIG_Py_Void();
24379 return resultobj;
24380 fail:
24381 return NULL;
24382 }
24383
24384
24385 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24386 PyObject *resultobj = 0;
24387 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24388 bool result;
24389 void *argp1 = 0 ;
24390 int res1 = 0 ;
24391 PyObject *swig_obj[1] ;
24392
24393 if (!args) SWIG_fail;
24394 swig_obj[0] = args;
24395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24396 if (!SWIG_IsOK(res1)) {
24397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24398 }
24399 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24400 {
24401 PyThreadState* __tstate = wxPyBeginAllowThreads();
24402 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24403 wxPyEndAllowThreads(__tstate);
24404 if (PyErr_Occurred()) SWIG_fail;
24405 }
24406 {
24407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24408 }
24409 return resultobj;
24410 fail:
24411 return NULL;
24412 }
24413
24414
24415 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24416 PyObject *resultobj = 0;
24417 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24418 bool arg2 = (bool) true ;
24419 void *argp1 = 0 ;
24420 int res1 = 0 ;
24421 bool val2 ;
24422 int ecode2 = 0 ;
24423 PyObject * obj0 = 0 ;
24424 PyObject * obj1 = 0 ;
24425 char * kwnames[] = {
24426 (char *) "self",(char *) "veto", NULL
24427 };
24428
24429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24431 if (!SWIG_IsOK(res1)) {
24432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24433 }
24434 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24435 if (obj1) {
24436 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24437 if (!SWIG_IsOK(ecode2)) {
24438 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24439 }
24440 arg2 = static_cast< bool >(val2);
24441 }
24442 {
24443 PyThreadState* __tstate = wxPyBeginAllowThreads();
24444 (arg1)->Veto(arg2);
24445 wxPyEndAllowThreads(__tstate);
24446 if (PyErr_Occurred()) SWIG_fail;
24447 }
24448 resultobj = SWIG_Py_Void();
24449 return resultobj;
24450 fail:
24451 return NULL;
24452 }
24453
24454
24455 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24456 PyObject *resultobj = 0;
24457 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24458 bool result;
24459 void *argp1 = 0 ;
24460 int res1 = 0 ;
24461 PyObject *swig_obj[1] ;
24462
24463 if (!args) SWIG_fail;
24464 swig_obj[0] = args;
24465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24466 if (!SWIG_IsOK(res1)) {
24467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24468 }
24469 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24470 {
24471 PyThreadState* __tstate = wxPyBeginAllowThreads();
24472 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24473 wxPyEndAllowThreads(__tstate);
24474 if (PyErr_Occurred()) SWIG_fail;
24475 }
24476 {
24477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24478 }
24479 return resultobj;
24480 fail:
24481 return NULL;
24482 }
24483
24484
24485 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24486 PyObject *resultobj = 0;
24487 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24488 bool arg2 ;
24489 void *argp1 = 0 ;
24490 int res1 = 0 ;
24491 bool val2 ;
24492 int ecode2 = 0 ;
24493 PyObject * obj0 = 0 ;
24494 PyObject * obj1 = 0 ;
24495 char * kwnames[] = {
24496 (char *) "self",(char *) "canVeto", NULL
24497 };
24498
24499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
24500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24501 if (!SWIG_IsOK(res1)) {
24502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24503 }
24504 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24505 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24506 if (!SWIG_IsOK(ecode2)) {
24507 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
24508 }
24509 arg2 = static_cast< bool >(val2);
24510 {
24511 PyThreadState* __tstate = wxPyBeginAllowThreads();
24512 (arg1)->SetCanVeto(arg2);
24513 wxPyEndAllowThreads(__tstate);
24514 if (PyErr_Occurred()) SWIG_fail;
24515 }
24516 resultobj = SWIG_Py_Void();
24517 return resultobj;
24518 fail:
24519 return NULL;
24520 }
24521
24522
24523 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24524 PyObject *resultobj = 0;
24525 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24526 bool result;
24527 void *argp1 = 0 ;
24528 int res1 = 0 ;
24529 PyObject *swig_obj[1] ;
24530
24531 if (!args) SWIG_fail;
24532 swig_obj[0] = args;
24533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24534 if (!SWIG_IsOK(res1)) {
24535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24536 }
24537 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24538 {
24539 PyThreadState* __tstate = wxPyBeginAllowThreads();
24540 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
24541 wxPyEndAllowThreads(__tstate);
24542 if (PyErr_Occurred()) SWIG_fail;
24543 }
24544 {
24545 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24546 }
24547 return resultobj;
24548 fail:
24549 return NULL;
24550 }
24551
24552
24553 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24554 PyObject *obj;
24555 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24556 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
24557 return SWIG_Py_Void();
24558 }
24559
24560 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24561 return SWIG_Python_InitShadowInstance(args);
24562 }
24563
24564 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24565 PyObject *resultobj = 0;
24566 int arg1 = (int) 0 ;
24567 bool arg2 = (bool) false ;
24568 wxShowEvent *result = 0 ;
24569 int val1 ;
24570 int ecode1 = 0 ;
24571 bool val2 ;
24572 int ecode2 = 0 ;
24573 PyObject * obj0 = 0 ;
24574 PyObject * obj1 = 0 ;
24575 char * kwnames[] = {
24576 (char *) "winid",(char *) "show", NULL
24577 };
24578
24579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24580 if (obj0) {
24581 ecode1 = SWIG_AsVal_int(obj0, &val1);
24582 if (!SWIG_IsOK(ecode1)) {
24583 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
24584 }
24585 arg1 = static_cast< int >(val1);
24586 }
24587 if (obj1) {
24588 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24589 if (!SWIG_IsOK(ecode2)) {
24590 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
24591 }
24592 arg2 = static_cast< bool >(val2);
24593 }
24594 {
24595 PyThreadState* __tstate = wxPyBeginAllowThreads();
24596 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
24597 wxPyEndAllowThreads(__tstate);
24598 if (PyErr_Occurred()) SWIG_fail;
24599 }
24600 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
24601 return resultobj;
24602 fail:
24603 return NULL;
24604 }
24605
24606
24607 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24608 PyObject *resultobj = 0;
24609 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24610 bool arg2 ;
24611 void *argp1 = 0 ;
24612 int res1 = 0 ;
24613 bool val2 ;
24614 int ecode2 = 0 ;
24615 PyObject * obj0 = 0 ;
24616 PyObject * obj1 = 0 ;
24617 char * kwnames[] = {
24618 (char *) "self",(char *) "show", NULL
24619 };
24620
24621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
24622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24623 if (!SWIG_IsOK(res1)) {
24624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
24625 }
24626 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24627 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24628 if (!SWIG_IsOK(ecode2)) {
24629 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
24630 }
24631 arg2 = static_cast< bool >(val2);
24632 {
24633 PyThreadState* __tstate = wxPyBeginAllowThreads();
24634 (arg1)->SetShow(arg2);
24635 wxPyEndAllowThreads(__tstate);
24636 if (PyErr_Occurred()) SWIG_fail;
24637 }
24638 resultobj = SWIG_Py_Void();
24639 return resultobj;
24640 fail:
24641 return NULL;
24642 }
24643
24644
24645 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24646 PyObject *resultobj = 0;
24647 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24648 bool result;
24649 void *argp1 = 0 ;
24650 int res1 = 0 ;
24651 PyObject *swig_obj[1] ;
24652
24653 if (!args) SWIG_fail;
24654 swig_obj[0] = args;
24655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24656 if (!SWIG_IsOK(res1)) {
24657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
24658 }
24659 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24660 {
24661 PyThreadState* __tstate = wxPyBeginAllowThreads();
24662 result = (bool)((wxShowEvent const *)arg1)->GetShow();
24663 wxPyEndAllowThreads(__tstate);
24664 if (PyErr_Occurred()) SWIG_fail;
24665 }
24666 {
24667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24668 }
24669 return resultobj;
24670 fail:
24671 return NULL;
24672 }
24673
24674
24675 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24676 PyObject *obj;
24677 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24678 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
24679 return SWIG_Py_Void();
24680 }
24681
24682 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24683 return SWIG_Python_InitShadowInstance(args);
24684 }
24685
24686 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24687 PyObject *resultobj = 0;
24688 int arg1 = (int) 0 ;
24689 bool arg2 = (bool) true ;
24690 wxIconizeEvent *result = 0 ;
24691 int val1 ;
24692 int ecode1 = 0 ;
24693 bool val2 ;
24694 int ecode2 = 0 ;
24695 PyObject * obj0 = 0 ;
24696 PyObject * obj1 = 0 ;
24697 char * kwnames[] = {
24698 (char *) "id",(char *) "iconized", NULL
24699 };
24700
24701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24702 if (obj0) {
24703 ecode1 = SWIG_AsVal_int(obj0, &val1);
24704 if (!SWIG_IsOK(ecode1)) {
24705 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
24706 }
24707 arg1 = static_cast< int >(val1);
24708 }
24709 if (obj1) {
24710 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24711 if (!SWIG_IsOK(ecode2)) {
24712 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
24713 }
24714 arg2 = static_cast< bool >(val2);
24715 }
24716 {
24717 PyThreadState* __tstate = wxPyBeginAllowThreads();
24718 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
24719 wxPyEndAllowThreads(__tstate);
24720 if (PyErr_Occurred()) SWIG_fail;
24721 }
24722 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
24723 return resultobj;
24724 fail:
24725 return NULL;
24726 }
24727
24728
24729 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24730 PyObject *resultobj = 0;
24731 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
24732 bool result;
24733 void *argp1 = 0 ;
24734 int res1 = 0 ;
24735 PyObject *swig_obj[1] ;
24736
24737 if (!args) SWIG_fail;
24738 swig_obj[0] = args;
24739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
24740 if (!SWIG_IsOK(res1)) {
24741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
24742 }
24743 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
24744 {
24745 PyThreadState* __tstate = wxPyBeginAllowThreads();
24746 result = (bool)(arg1)->Iconized();
24747 wxPyEndAllowThreads(__tstate);
24748 if (PyErr_Occurred()) SWIG_fail;
24749 }
24750 {
24751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24752 }
24753 return resultobj;
24754 fail:
24755 return NULL;
24756 }
24757
24758
24759 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24760 PyObject *obj;
24761 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24762 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
24763 return SWIG_Py_Void();
24764 }
24765
24766 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24767 return SWIG_Python_InitShadowInstance(args);
24768 }
24769
24770 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24771 PyObject *resultobj = 0;
24772 int arg1 = (int) 0 ;
24773 wxMaximizeEvent *result = 0 ;
24774 int val1 ;
24775 int ecode1 = 0 ;
24776 PyObject * obj0 = 0 ;
24777 char * kwnames[] = {
24778 (char *) "id", NULL
24779 };
24780
24781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
24782 if (obj0) {
24783 ecode1 = SWIG_AsVal_int(obj0, &val1);
24784 if (!SWIG_IsOK(ecode1)) {
24785 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
24786 }
24787 arg1 = static_cast< int >(val1);
24788 }
24789 {
24790 PyThreadState* __tstate = wxPyBeginAllowThreads();
24791 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
24792 wxPyEndAllowThreads(__tstate);
24793 if (PyErr_Occurred()) SWIG_fail;
24794 }
24795 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
24796 return resultobj;
24797 fail:
24798 return NULL;
24799 }
24800
24801
24802 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24803 PyObject *obj;
24804 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24805 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
24806 return SWIG_Py_Void();
24807 }
24808
24809 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24810 return SWIG_Python_InitShadowInstance(args);
24811 }
24812
24813 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24814 PyObject *resultobj = 0;
24815 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24816 wxPoint result;
24817 void *argp1 = 0 ;
24818 int res1 = 0 ;
24819 PyObject *swig_obj[1] ;
24820
24821 if (!args) SWIG_fail;
24822 swig_obj[0] = args;
24823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24824 if (!SWIG_IsOK(res1)) {
24825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24826 }
24827 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24828 {
24829 PyThreadState* __tstate = wxPyBeginAllowThreads();
24830 result = (arg1)->GetPosition();
24831 wxPyEndAllowThreads(__tstate);
24832 if (PyErr_Occurred()) SWIG_fail;
24833 }
24834 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24835 return resultobj;
24836 fail:
24837 return NULL;
24838 }
24839
24840
24841 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24842 PyObject *resultobj = 0;
24843 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24844 int result;
24845 void *argp1 = 0 ;
24846 int res1 = 0 ;
24847 PyObject *swig_obj[1] ;
24848
24849 if (!args) SWIG_fail;
24850 swig_obj[0] = args;
24851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24852 if (!SWIG_IsOK(res1)) {
24853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24854 }
24855 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24856 {
24857 PyThreadState* __tstate = wxPyBeginAllowThreads();
24858 result = (int)(arg1)->GetNumberOfFiles();
24859 wxPyEndAllowThreads(__tstate);
24860 if (PyErr_Occurred()) SWIG_fail;
24861 }
24862 resultobj = SWIG_From_int(static_cast< int >(result));
24863 return resultobj;
24864 fail:
24865 return NULL;
24866 }
24867
24868
24869 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24870 PyObject *resultobj = 0;
24871 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24872 PyObject *result = 0 ;
24873 void *argp1 = 0 ;
24874 int res1 = 0 ;
24875 PyObject *swig_obj[1] ;
24876
24877 if (!args) SWIG_fail;
24878 swig_obj[0] = args;
24879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24880 if (!SWIG_IsOK(res1)) {
24881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24882 }
24883 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24884 {
24885 PyThreadState* __tstate = wxPyBeginAllowThreads();
24886 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
24887 wxPyEndAllowThreads(__tstate);
24888 if (PyErr_Occurred()) SWIG_fail;
24889 }
24890 resultobj = result;
24891 return resultobj;
24892 fail:
24893 return NULL;
24894 }
24895
24896
24897 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24898 PyObject *obj;
24899 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24900 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
24901 return SWIG_Py_Void();
24902 }
24903
24904 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24905 PyObject *resultobj = 0;
24906 int arg1 = (int) 0 ;
24907 wxUpdateUIEvent *result = 0 ;
24908 int val1 ;
24909 int ecode1 = 0 ;
24910 PyObject * obj0 = 0 ;
24911 char * kwnames[] = {
24912 (char *) "commandId", NULL
24913 };
24914
24915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
24916 if (obj0) {
24917 ecode1 = SWIG_AsVal_int(obj0, &val1);
24918 if (!SWIG_IsOK(ecode1)) {
24919 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
24920 }
24921 arg1 = static_cast< int >(val1);
24922 }
24923 {
24924 PyThreadState* __tstate = wxPyBeginAllowThreads();
24925 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
24926 wxPyEndAllowThreads(__tstate);
24927 if (PyErr_Occurred()) SWIG_fail;
24928 }
24929 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
24930 return resultobj;
24931 fail:
24932 return NULL;
24933 }
24934
24935
24936 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24937 PyObject *resultobj = 0;
24938 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24939 bool result;
24940 void *argp1 = 0 ;
24941 int res1 = 0 ;
24942 PyObject *swig_obj[1] ;
24943
24944 if (!args) SWIG_fail;
24945 swig_obj[0] = args;
24946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24947 if (!SWIG_IsOK(res1)) {
24948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24949 }
24950 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24951 {
24952 PyThreadState* __tstate = wxPyBeginAllowThreads();
24953 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
24954 wxPyEndAllowThreads(__tstate);
24955 if (PyErr_Occurred()) SWIG_fail;
24956 }
24957 {
24958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24959 }
24960 return resultobj;
24961 fail:
24962 return NULL;
24963 }
24964
24965
24966 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24967 PyObject *resultobj = 0;
24968 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24969 bool result;
24970 void *argp1 = 0 ;
24971 int res1 = 0 ;
24972 PyObject *swig_obj[1] ;
24973
24974 if (!args) SWIG_fail;
24975 swig_obj[0] = args;
24976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24977 if (!SWIG_IsOK(res1)) {
24978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24979 }
24980 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24981 {
24982 PyThreadState* __tstate = wxPyBeginAllowThreads();
24983 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
24984 wxPyEndAllowThreads(__tstate);
24985 if (PyErr_Occurred()) SWIG_fail;
24986 }
24987 {
24988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24989 }
24990 return resultobj;
24991 fail:
24992 return NULL;
24993 }
24994
24995
24996 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24997 PyObject *resultobj = 0;
24998 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24999 bool result;
25000 void *argp1 = 0 ;
25001 int res1 = 0 ;
25002 PyObject *swig_obj[1] ;
25003
25004 if (!args) SWIG_fail;
25005 swig_obj[0] = args;
25006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25007 if (!SWIG_IsOK(res1)) {
25008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25009 }
25010 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25011 {
25012 PyThreadState* __tstate = wxPyBeginAllowThreads();
25013 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
25014 wxPyEndAllowThreads(__tstate);
25015 if (PyErr_Occurred()) SWIG_fail;
25016 }
25017 {
25018 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25019 }
25020 return resultobj;
25021 fail:
25022 return NULL;
25023 }
25024
25025
25026 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25027 PyObject *resultobj = 0;
25028 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25029 wxString result;
25030 void *argp1 = 0 ;
25031 int res1 = 0 ;
25032 PyObject *swig_obj[1] ;
25033
25034 if (!args) SWIG_fail;
25035 swig_obj[0] = args;
25036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25037 if (!SWIG_IsOK(res1)) {
25038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25039 }
25040 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25041 {
25042 PyThreadState* __tstate = wxPyBeginAllowThreads();
25043 result = ((wxUpdateUIEvent const *)arg1)->GetText();
25044 wxPyEndAllowThreads(__tstate);
25045 if (PyErr_Occurred()) SWIG_fail;
25046 }
25047 {
25048 #if wxUSE_UNICODE
25049 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25050 #else
25051 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25052 #endif
25053 }
25054 return resultobj;
25055 fail:
25056 return NULL;
25057 }
25058
25059
25060 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25061 PyObject *resultobj = 0;
25062 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25063 bool result;
25064 void *argp1 = 0 ;
25065 int res1 = 0 ;
25066 PyObject *swig_obj[1] ;
25067
25068 if (!args) SWIG_fail;
25069 swig_obj[0] = args;
25070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25071 if (!SWIG_IsOK(res1)) {
25072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25073 }
25074 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25075 {
25076 PyThreadState* __tstate = wxPyBeginAllowThreads();
25077 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
25078 wxPyEndAllowThreads(__tstate);
25079 if (PyErr_Occurred()) SWIG_fail;
25080 }
25081 {
25082 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25083 }
25084 return resultobj;
25085 fail:
25086 return NULL;
25087 }
25088
25089
25090 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25091 PyObject *resultobj = 0;
25092 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25093 bool result;
25094 void *argp1 = 0 ;
25095 int res1 = 0 ;
25096 PyObject *swig_obj[1] ;
25097
25098 if (!args) SWIG_fail;
25099 swig_obj[0] = args;
25100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25101 if (!SWIG_IsOK(res1)) {
25102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25103 }
25104 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25105 {
25106 PyThreadState* __tstate = wxPyBeginAllowThreads();
25107 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
25108 wxPyEndAllowThreads(__tstate);
25109 if (PyErr_Occurred()) SWIG_fail;
25110 }
25111 {
25112 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25113 }
25114 return resultobj;
25115 fail:
25116 return NULL;
25117 }
25118
25119
25120 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25121 PyObject *resultobj = 0;
25122 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25123 bool result;
25124 void *argp1 = 0 ;
25125 int res1 = 0 ;
25126 PyObject *swig_obj[1] ;
25127
25128 if (!args) SWIG_fail;
25129 swig_obj[0] = args;
25130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25131 if (!SWIG_IsOK(res1)) {
25132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25133 }
25134 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25135 {
25136 PyThreadState* __tstate = wxPyBeginAllowThreads();
25137 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
25138 wxPyEndAllowThreads(__tstate);
25139 if (PyErr_Occurred()) SWIG_fail;
25140 }
25141 {
25142 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25143 }
25144 return resultobj;
25145 fail:
25146 return NULL;
25147 }
25148
25149
25150 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25151 PyObject *resultobj = 0;
25152 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25153 bool result;
25154 void *argp1 = 0 ;
25155 int res1 = 0 ;
25156 PyObject *swig_obj[1] ;
25157
25158 if (!args) SWIG_fail;
25159 swig_obj[0] = args;
25160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25161 if (!SWIG_IsOK(res1)) {
25162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25163 }
25164 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25165 {
25166 PyThreadState* __tstate = wxPyBeginAllowThreads();
25167 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
25168 wxPyEndAllowThreads(__tstate);
25169 if (PyErr_Occurred()) SWIG_fail;
25170 }
25171 {
25172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25173 }
25174 return resultobj;
25175 fail:
25176 return NULL;
25177 }
25178
25179
25180 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25181 PyObject *resultobj = 0;
25182 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25183 bool arg2 ;
25184 void *argp1 = 0 ;
25185 int res1 = 0 ;
25186 bool val2 ;
25187 int ecode2 = 0 ;
25188 PyObject * obj0 = 0 ;
25189 PyObject * obj1 = 0 ;
25190 char * kwnames[] = {
25191 (char *) "self",(char *) "check", NULL
25192 };
25193
25194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
25195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25196 if (!SWIG_IsOK(res1)) {
25197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25198 }
25199 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25200 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25201 if (!SWIG_IsOK(ecode2)) {
25202 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
25203 }
25204 arg2 = static_cast< bool >(val2);
25205 {
25206 PyThreadState* __tstate = wxPyBeginAllowThreads();
25207 (arg1)->Check(arg2);
25208 wxPyEndAllowThreads(__tstate);
25209 if (PyErr_Occurred()) SWIG_fail;
25210 }
25211 resultobj = SWIG_Py_Void();
25212 return resultobj;
25213 fail:
25214 return NULL;
25215 }
25216
25217
25218 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25219 PyObject *resultobj = 0;
25220 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25221 bool arg2 ;
25222 void *argp1 = 0 ;
25223 int res1 = 0 ;
25224 bool val2 ;
25225 int ecode2 = 0 ;
25226 PyObject * obj0 = 0 ;
25227 PyObject * obj1 = 0 ;
25228 char * kwnames[] = {
25229 (char *) "self",(char *) "enable", NULL
25230 };
25231
25232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
25233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25234 if (!SWIG_IsOK(res1)) {
25235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25236 }
25237 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25238 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25239 if (!SWIG_IsOK(ecode2)) {
25240 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
25241 }
25242 arg2 = static_cast< bool >(val2);
25243 {
25244 PyThreadState* __tstate = wxPyBeginAllowThreads();
25245 (arg1)->Enable(arg2);
25246 wxPyEndAllowThreads(__tstate);
25247 if (PyErr_Occurred()) SWIG_fail;
25248 }
25249 resultobj = SWIG_Py_Void();
25250 return resultobj;
25251 fail:
25252 return NULL;
25253 }
25254
25255
25256 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25257 PyObject *resultobj = 0;
25258 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25259 bool arg2 ;
25260 void *argp1 = 0 ;
25261 int res1 = 0 ;
25262 bool val2 ;
25263 int ecode2 = 0 ;
25264 PyObject * obj0 = 0 ;
25265 PyObject * obj1 = 0 ;
25266 char * kwnames[] = {
25267 (char *) "self",(char *) "show", NULL
25268 };
25269
25270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
25271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25272 if (!SWIG_IsOK(res1)) {
25273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25274 }
25275 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25276 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25277 if (!SWIG_IsOK(ecode2)) {
25278 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
25279 }
25280 arg2 = static_cast< bool >(val2);
25281 {
25282 PyThreadState* __tstate = wxPyBeginAllowThreads();
25283 (arg1)->Show(arg2);
25284 wxPyEndAllowThreads(__tstate);
25285 if (PyErr_Occurred()) SWIG_fail;
25286 }
25287 resultobj = SWIG_Py_Void();
25288 return resultobj;
25289 fail:
25290 return NULL;
25291 }
25292
25293
25294 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25295 PyObject *resultobj = 0;
25296 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25297 wxString *arg2 = 0 ;
25298 void *argp1 = 0 ;
25299 int res1 = 0 ;
25300 bool temp2 = false ;
25301 PyObject * obj0 = 0 ;
25302 PyObject * obj1 = 0 ;
25303 char * kwnames[] = {
25304 (char *) "self",(char *) "text", NULL
25305 };
25306
25307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25309 if (!SWIG_IsOK(res1)) {
25310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25311 }
25312 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25313 {
25314 arg2 = wxString_in_helper(obj1);
25315 if (arg2 == NULL) SWIG_fail;
25316 temp2 = true;
25317 }
25318 {
25319 PyThreadState* __tstate = wxPyBeginAllowThreads();
25320 (arg1)->SetText((wxString const &)*arg2);
25321 wxPyEndAllowThreads(__tstate);
25322 if (PyErr_Occurred()) SWIG_fail;
25323 }
25324 resultobj = SWIG_Py_Void();
25325 {
25326 if (temp2)
25327 delete arg2;
25328 }
25329 return resultobj;
25330 fail:
25331 {
25332 if (temp2)
25333 delete arg2;
25334 }
25335 return NULL;
25336 }
25337
25338
25339 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25340 PyObject *resultobj = 0;
25341 long arg1 ;
25342 long val1 ;
25343 int ecode1 = 0 ;
25344 PyObject * obj0 = 0 ;
25345 char * kwnames[] = {
25346 (char *) "updateInterval", NULL
25347 };
25348
25349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
25350 ecode1 = SWIG_AsVal_long(obj0, &val1);
25351 if (!SWIG_IsOK(ecode1)) {
25352 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
25353 }
25354 arg1 = static_cast< long >(val1);
25355 {
25356 PyThreadState* __tstate = wxPyBeginAllowThreads();
25357 wxUpdateUIEvent::SetUpdateInterval(arg1);
25358 wxPyEndAllowThreads(__tstate);
25359 if (PyErr_Occurred()) SWIG_fail;
25360 }
25361 resultobj = SWIG_Py_Void();
25362 return resultobj;
25363 fail:
25364 return NULL;
25365 }
25366
25367
25368 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25369 PyObject *resultobj = 0;
25370 long result;
25371
25372 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25373 {
25374 PyThreadState* __tstate = wxPyBeginAllowThreads();
25375 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25376 wxPyEndAllowThreads(__tstate);
25377 if (PyErr_Occurred()) SWIG_fail;
25378 }
25379 resultobj = SWIG_From_long(static_cast< long >(result));
25380 return resultobj;
25381 fail:
25382 return NULL;
25383 }
25384
25385
25386 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25387 PyObject *resultobj = 0;
25388 wxWindow *arg1 = (wxWindow *) 0 ;
25389 bool result;
25390 void *argp1 = 0 ;
25391 int res1 = 0 ;
25392 PyObject * obj0 = 0 ;
25393 char * kwnames[] = {
25394 (char *) "win", NULL
25395 };
25396
25397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25399 if (!SWIG_IsOK(res1)) {
25400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25401 }
25402 arg1 = reinterpret_cast< wxWindow * >(argp1);
25403 {
25404 PyThreadState* __tstate = wxPyBeginAllowThreads();
25405 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25406 wxPyEndAllowThreads(__tstate);
25407 if (PyErr_Occurred()) SWIG_fail;
25408 }
25409 {
25410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25411 }
25412 return resultobj;
25413 fail:
25414 return NULL;
25415 }
25416
25417
25418 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25419 PyObject *resultobj = 0;
25420
25421 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25422 {
25423 PyThreadState* __tstate = wxPyBeginAllowThreads();
25424 wxUpdateUIEvent::ResetUpdateTime();
25425 wxPyEndAllowThreads(__tstate);
25426 if (PyErr_Occurred()) SWIG_fail;
25427 }
25428 resultobj = SWIG_Py_Void();
25429 return resultobj;
25430 fail:
25431 return NULL;
25432 }
25433
25434
25435 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25436 PyObject *resultobj = 0;
25437 wxUpdateUIMode arg1 ;
25438 int val1 ;
25439 int ecode1 = 0 ;
25440 PyObject * obj0 = 0 ;
25441 char * kwnames[] = {
25442 (char *) "mode", NULL
25443 };
25444
25445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25446 ecode1 = SWIG_AsVal_int(obj0, &val1);
25447 if (!SWIG_IsOK(ecode1)) {
25448 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25449 }
25450 arg1 = static_cast< wxUpdateUIMode >(val1);
25451 {
25452 PyThreadState* __tstate = wxPyBeginAllowThreads();
25453 wxUpdateUIEvent::SetMode(arg1);
25454 wxPyEndAllowThreads(__tstate);
25455 if (PyErr_Occurred()) SWIG_fail;
25456 }
25457 resultobj = SWIG_Py_Void();
25458 return resultobj;
25459 fail:
25460 return NULL;
25461 }
25462
25463
25464 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25465 PyObject *resultobj = 0;
25466 wxUpdateUIMode result;
25467
25468 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25469 {
25470 PyThreadState* __tstate = wxPyBeginAllowThreads();
25471 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25472 wxPyEndAllowThreads(__tstate);
25473 if (PyErr_Occurred()) SWIG_fail;
25474 }
25475 resultobj = SWIG_From_int(static_cast< int >(result));
25476 return resultobj;
25477 fail:
25478 return NULL;
25479 }
25480
25481
25482 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25483 PyObject *obj;
25484 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25485 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
25486 return SWIG_Py_Void();
25487 }
25488
25489 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25490 return SWIG_Python_InitShadowInstance(args);
25491 }
25492
25493 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25494 PyObject *resultobj = 0;
25495 wxSysColourChangedEvent *result = 0 ;
25496
25497 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
25498 {
25499 PyThreadState* __tstate = wxPyBeginAllowThreads();
25500 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
25501 wxPyEndAllowThreads(__tstate);
25502 if (PyErr_Occurred()) SWIG_fail;
25503 }
25504 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
25505 return resultobj;
25506 fail:
25507 return NULL;
25508 }
25509
25510
25511 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25512 PyObject *obj;
25513 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25514 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
25515 return SWIG_Py_Void();
25516 }
25517
25518 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25519 return SWIG_Python_InitShadowInstance(args);
25520 }
25521
25522 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25523 PyObject *resultobj = 0;
25524 int arg1 = (int) 0 ;
25525 wxWindow *arg2 = (wxWindow *) NULL ;
25526 wxMouseCaptureChangedEvent *result = 0 ;
25527 int val1 ;
25528 int ecode1 = 0 ;
25529 void *argp2 = 0 ;
25530 int res2 = 0 ;
25531 PyObject * obj0 = 0 ;
25532 PyObject * obj1 = 0 ;
25533 char * kwnames[] = {
25534 (char *) "winid",(char *) "gainedCapture", NULL
25535 };
25536
25537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25538 if (obj0) {
25539 ecode1 = SWIG_AsVal_int(obj0, &val1);
25540 if (!SWIG_IsOK(ecode1)) {
25541 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
25542 }
25543 arg1 = static_cast< int >(val1);
25544 }
25545 if (obj1) {
25546 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25547 if (!SWIG_IsOK(res2)) {
25548 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
25549 }
25550 arg2 = reinterpret_cast< wxWindow * >(argp2);
25551 }
25552 {
25553 PyThreadState* __tstate = wxPyBeginAllowThreads();
25554 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
25555 wxPyEndAllowThreads(__tstate);
25556 if (PyErr_Occurred()) SWIG_fail;
25557 }
25558 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
25559 return resultobj;
25560 fail:
25561 return NULL;
25562 }
25563
25564
25565 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25566 PyObject *resultobj = 0;
25567 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
25568 wxWindow *result = 0 ;
25569 void *argp1 = 0 ;
25570 int res1 = 0 ;
25571 PyObject *swig_obj[1] ;
25572
25573 if (!args) SWIG_fail;
25574 swig_obj[0] = args;
25575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
25576 if (!SWIG_IsOK(res1)) {
25577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
25578 }
25579 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
25580 {
25581 PyThreadState* __tstate = wxPyBeginAllowThreads();
25582 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
25583 wxPyEndAllowThreads(__tstate);
25584 if (PyErr_Occurred()) SWIG_fail;
25585 }
25586 {
25587 resultobj = wxPyMake_wxObject(result, (bool)0);
25588 }
25589 return resultobj;
25590 fail:
25591 return NULL;
25592 }
25593
25594
25595 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25596 PyObject *obj;
25597 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25598 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
25599 return SWIG_Py_Void();
25600 }
25601
25602 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25603 return SWIG_Python_InitShadowInstance(args);
25604 }
25605
25606 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25607 PyObject *resultobj = 0;
25608 int arg1 = (int) 0 ;
25609 wxMouseCaptureLostEvent *result = 0 ;
25610 int val1 ;
25611 int ecode1 = 0 ;
25612 PyObject * obj0 = 0 ;
25613 char * kwnames[] = {
25614 (char *) "winid", NULL
25615 };
25616
25617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
25618 if (obj0) {
25619 ecode1 = SWIG_AsVal_int(obj0, &val1);
25620 if (!SWIG_IsOK(ecode1)) {
25621 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
25622 }
25623 arg1 = static_cast< int >(val1);
25624 }
25625 {
25626 PyThreadState* __tstate = wxPyBeginAllowThreads();
25627 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
25628 wxPyEndAllowThreads(__tstate);
25629 if (PyErr_Occurred()) SWIG_fail;
25630 }
25631 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
25632 return resultobj;
25633 fail:
25634 return NULL;
25635 }
25636
25637
25638 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25639 PyObject *obj;
25640 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25641 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
25642 return SWIG_Py_Void();
25643 }
25644
25645 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25646 return SWIG_Python_InitShadowInstance(args);
25647 }
25648
25649 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25650 PyObject *resultobj = 0;
25651 wxDisplayChangedEvent *result = 0 ;
25652
25653 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
25654 {
25655 PyThreadState* __tstate = wxPyBeginAllowThreads();
25656 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
25657 wxPyEndAllowThreads(__tstate);
25658 if (PyErr_Occurred()) SWIG_fail;
25659 }
25660 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
25661 return resultobj;
25662 fail:
25663 return NULL;
25664 }
25665
25666
25667 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25668 PyObject *obj;
25669 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25670 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
25671 return SWIG_Py_Void();
25672 }
25673
25674 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25675 return SWIG_Python_InitShadowInstance(args);
25676 }
25677
25678 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25679 PyObject *resultobj = 0;
25680 int arg1 = (int) 0 ;
25681 wxPaletteChangedEvent *result = 0 ;
25682 int val1 ;
25683 int ecode1 = 0 ;
25684 PyObject * obj0 = 0 ;
25685 char * kwnames[] = {
25686 (char *) "id", NULL
25687 };
25688
25689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
25690 if (obj0) {
25691 ecode1 = SWIG_AsVal_int(obj0, &val1);
25692 if (!SWIG_IsOK(ecode1)) {
25693 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
25694 }
25695 arg1 = static_cast< int >(val1);
25696 }
25697 {
25698 PyThreadState* __tstate = wxPyBeginAllowThreads();
25699 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
25700 wxPyEndAllowThreads(__tstate);
25701 if (PyErr_Occurred()) SWIG_fail;
25702 }
25703 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
25704 return resultobj;
25705 fail:
25706 return NULL;
25707 }
25708
25709
25710 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25711 PyObject *resultobj = 0;
25712 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25713 wxWindow *arg2 = (wxWindow *) 0 ;
25714 void *argp1 = 0 ;
25715 int res1 = 0 ;
25716 void *argp2 = 0 ;
25717 int res2 = 0 ;
25718 PyObject * obj0 = 0 ;
25719 PyObject * obj1 = 0 ;
25720 char * kwnames[] = {
25721 (char *) "self",(char *) "win", NULL
25722 };
25723
25724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
25725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25726 if (!SWIG_IsOK(res1)) {
25727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25728 }
25729 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25730 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25731 if (!SWIG_IsOK(res2)) {
25732 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
25733 }
25734 arg2 = reinterpret_cast< wxWindow * >(argp2);
25735 {
25736 PyThreadState* __tstate = wxPyBeginAllowThreads();
25737 (arg1)->SetChangedWindow(arg2);
25738 wxPyEndAllowThreads(__tstate);
25739 if (PyErr_Occurred()) SWIG_fail;
25740 }
25741 resultobj = SWIG_Py_Void();
25742 return resultobj;
25743 fail:
25744 return NULL;
25745 }
25746
25747
25748 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25749 PyObject *resultobj = 0;
25750 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25751 wxWindow *result = 0 ;
25752 void *argp1 = 0 ;
25753 int res1 = 0 ;
25754 PyObject *swig_obj[1] ;
25755
25756 if (!args) SWIG_fail;
25757 swig_obj[0] = args;
25758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25759 if (!SWIG_IsOK(res1)) {
25760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25761 }
25762 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25763 {
25764 PyThreadState* __tstate = wxPyBeginAllowThreads();
25765 result = (wxWindow *)(arg1)->GetChangedWindow();
25766 wxPyEndAllowThreads(__tstate);
25767 if (PyErr_Occurred()) SWIG_fail;
25768 }
25769 {
25770 resultobj = wxPyMake_wxObject(result, (bool)0);
25771 }
25772 return resultobj;
25773 fail:
25774 return NULL;
25775 }
25776
25777
25778 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25779 PyObject *obj;
25780 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25781 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
25782 return SWIG_Py_Void();
25783 }
25784
25785 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25786 return SWIG_Python_InitShadowInstance(args);
25787 }
25788
25789 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25790 PyObject *resultobj = 0;
25791 int arg1 = (int) 0 ;
25792 wxQueryNewPaletteEvent *result = 0 ;
25793 int val1 ;
25794 int ecode1 = 0 ;
25795 PyObject * obj0 = 0 ;
25796 char * kwnames[] = {
25797 (char *) "winid", NULL
25798 };
25799
25800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
25801 if (obj0) {
25802 ecode1 = SWIG_AsVal_int(obj0, &val1);
25803 if (!SWIG_IsOK(ecode1)) {
25804 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
25805 }
25806 arg1 = static_cast< int >(val1);
25807 }
25808 {
25809 PyThreadState* __tstate = wxPyBeginAllowThreads();
25810 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
25811 wxPyEndAllowThreads(__tstate);
25812 if (PyErr_Occurred()) SWIG_fail;
25813 }
25814 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
25815 return resultobj;
25816 fail:
25817 return NULL;
25818 }
25819
25820
25821 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25822 PyObject *resultobj = 0;
25823 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25824 bool arg2 ;
25825 void *argp1 = 0 ;
25826 int res1 = 0 ;
25827 bool val2 ;
25828 int ecode2 = 0 ;
25829 PyObject * obj0 = 0 ;
25830 PyObject * obj1 = 0 ;
25831 char * kwnames[] = {
25832 (char *) "self",(char *) "realized", NULL
25833 };
25834
25835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
25836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25837 if (!SWIG_IsOK(res1)) {
25838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
25839 }
25840 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25841 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25842 if (!SWIG_IsOK(ecode2)) {
25843 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
25844 }
25845 arg2 = static_cast< bool >(val2);
25846 {
25847 PyThreadState* __tstate = wxPyBeginAllowThreads();
25848 (arg1)->SetPaletteRealized(arg2);
25849 wxPyEndAllowThreads(__tstate);
25850 if (PyErr_Occurred()) SWIG_fail;
25851 }
25852 resultobj = SWIG_Py_Void();
25853 return resultobj;
25854 fail:
25855 return NULL;
25856 }
25857
25858
25859 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25860 PyObject *resultobj = 0;
25861 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25862 bool result;
25863 void *argp1 = 0 ;
25864 int res1 = 0 ;
25865 PyObject *swig_obj[1] ;
25866
25867 if (!args) SWIG_fail;
25868 swig_obj[0] = args;
25869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25870 if (!SWIG_IsOK(res1)) {
25871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
25872 }
25873 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25874 {
25875 PyThreadState* __tstate = wxPyBeginAllowThreads();
25876 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
25877 wxPyEndAllowThreads(__tstate);
25878 if (PyErr_Occurred()) SWIG_fail;
25879 }
25880 {
25881 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25882 }
25883 return resultobj;
25884 fail:
25885 return NULL;
25886 }
25887
25888
25889 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25890 PyObject *obj;
25891 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25892 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
25893 return SWIG_Py_Void();
25894 }
25895
25896 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25897 return SWIG_Python_InitShadowInstance(args);
25898 }
25899
25900 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25901 PyObject *resultobj = 0;
25902 wxNavigationKeyEvent *result = 0 ;
25903
25904 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
25905 {
25906 PyThreadState* __tstate = wxPyBeginAllowThreads();
25907 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
25908 wxPyEndAllowThreads(__tstate);
25909 if (PyErr_Occurred()) SWIG_fail;
25910 }
25911 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
25912 return resultobj;
25913 fail:
25914 return NULL;
25915 }
25916
25917
25918 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25919 PyObject *resultobj = 0;
25920 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25921 bool result;
25922 void *argp1 = 0 ;
25923 int res1 = 0 ;
25924 PyObject *swig_obj[1] ;
25925
25926 if (!args) SWIG_fail;
25927 swig_obj[0] = args;
25928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25929 if (!SWIG_IsOK(res1)) {
25930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25931 }
25932 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25933 {
25934 PyThreadState* __tstate = wxPyBeginAllowThreads();
25935 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
25936 wxPyEndAllowThreads(__tstate);
25937 if (PyErr_Occurred()) SWIG_fail;
25938 }
25939 {
25940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25941 }
25942 return resultobj;
25943 fail:
25944 return NULL;
25945 }
25946
25947
25948 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25949 PyObject *resultobj = 0;
25950 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25951 bool arg2 ;
25952 void *argp1 = 0 ;
25953 int res1 = 0 ;
25954 bool val2 ;
25955 int ecode2 = 0 ;
25956 PyObject * obj0 = 0 ;
25957 PyObject * obj1 = 0 ;
25958 char * kwnames[] = {
25959 (char *) "self",(char *) "forward", NULL
25960 };
25961
25962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
25963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25964 if (!SWIG_IsOK(res1)) {
25965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25966 }
25967 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25968 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25969 if (!SWIG_IsOK(ecode2)) {
25970 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
25971 }
25972 arg2 = static_cast< bool >(val2);
25973 {
25974 PyThreadState* __tstate = wxPyBeginAllowThreads();
25975 (arg1)->SetDirection(arg2);
25976 wxPyEndAllowThreads(__tstate);
25977 if (PyErr_Occurred()) SWIG_fail;
25978 }
25979 resultobj = SWIG_Py_Void();
25980 return resultobj;
25981 fail:
25982 return NULL;
25983 }
25984
25985
25986 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25987 PyObject *resultobj = 0;
25988 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25989 bool result;
25990 void *argp1 = 0 ;
25991 int res1 = 0 ;
25992 PyObject *swig_obj[1] ;
25993
25994 if (!args) SWIG_fail;
25995 swig_obj[0] = args;
25996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25997 if (!SWIG_IsOK(res1)) {
25998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25999 }
26000 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26001 {
26002 PyThreadState* __tstate = wxPyBeginAllowThreads();
26003 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
26004 wxPyEndAllowThreads(__tstate);
26005 if (PyErr_Occurred()) SWIG_fail;
26006 }
26007 {
26008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26009 }
26010 return resultobj;
26011 fail:
26012 return NULL;
26013 }
26014
26015
26016 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26017 PyObject *resultobj = 0;
26018 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26019 bool arg2 ;
26020 void *argp1 = 0 ;
26021 int res1 = 0 ;
26022 bool val2 ;
26023 int ecode2 = 0 ;
26024 PyObject * obj0 = 0 ;
26025 PyObject * obj1 = 0 ;
26026 char * kwnames[] = {
26027 (char *) "self",(char *) "ischange", NULL
26028 };
26029
26030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
26031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26032 if (!SWIG_IsOK(res1)) {
26033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26034 }
26035 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26036 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26037 if (!SWIG_IsOK(ecode2)) {
26038 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
26039 }
26040 arg2 = static_cast< bool >(val2);
26041 {
26042 PyThreadState* __tstate = wxPyBeginAllowThreads();
26043 (arg1)->SetWindowChange(arg2);
26044 wxPyEndAllowThreads(__tstate);
26045 if (PyErr_Occurred()) SWIG_fail;
26046 }
26047 resultobj = SWIG_Py_Void();
26048 return resultobj;
26049 fail:
26050 return NULL;
26051 }
26052
26053
26054 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26055 PyObject *resultobj = 0;
26056 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26057 bool result;
26058 void *argp1 = 0 ;
26059 int res1 = 0 ;
26060 PyObject *swig_obj[1] ;
26061
26062 if (!args) SWIG_fail;
26063 swig_obj[0] = args;
26064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26065 if (!SWIG_IsOK(res1)) {
26066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26067 }
26068 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26069 {
26070 PyThreadState* __tstate = wxPyBeginAllowThreads();
26071 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
26072 wxPyEndAllowThreads(__tstate);
26073 if (PyErr_Occurred()) SWIG_fail;
26074 }
26075 {
26076 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26077 }
26078 return resultobj;
26079 fail:
26080 return NULL;
26081 }
26082
26083
26084 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26085 PyObject *resultobj = 0;
26086 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26087 bool arg2 ;
26088 void *argp1 = 0 ;
26089 int res1 = 0 ;
26090 bool val2 ;
26091 int ecode2 = 0 ;
26092 PyObject * obj0 = 0 ;
26093 PyObject * obj1 = 0 ;
26094 char * kwnames[] = {
26095 (char *) "self",(char *) "bIs", NULL
26096 };
26097
26098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
26099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26100 if (!SWIG_IsOK(res1)) {
26101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26102 }
26103 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26104 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26105 if (!SWIG_IsOK(ecode2)) {
26106 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
26107 }
26108 arg2 = static_cast< bool >(val2);
26109 {
26110 PyThreadState* __tstate = wxPyBeginAllowThreads();
26111 (arg1)->SetFromTab(arg2);
26112 wxPyEndAllowThreads(__tstate);
26113 if (PyErr_Occurred()) SWIG_fail;
26114 }
26115 resultobj = SWIG_Py_Void();
26116 return resultobj;
26117 fail:
26118 return NULL;
26119 }
26120
26121
26122 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26123 PyObject *resultobj = 0;
26124 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26125 long arg2 ;
26126 void *argp1 = 0 ;
26127 int res1 = 0 ;
26128 long val2 ;
26129 int ecode2 = 0 ;
26130 PyObject * obj0 = 0 ;
26131 PyObject * obj1 = 0 ;
26132 char * kwnames[] = {
26133 (char *) "self",(char *) "flags", NULL
26134 };
26135
26136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
26137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26138 if (!SWIG_IsOK(res1)) {
26139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26140 }
26141 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26142 ecode2 = SWIG_AsVal_long(obj1, &val2);
26143 if (!SWIG_IsOK(ecode2)) {
26144 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
26145 }
26146 arg2 = static_cast< long >(val2);
26147 {
26148 PyThreadState* __tstate = wxPyBeginAllowThreads();
26149 (arg1)->SetFlags(arg2);
26150 wxPyEndAllowThreads(__tstate);
26151 if (PyErr_Occurred()) SWIG_fail;
26152 }
26153 resultobj = SWIG_Py_Void();
26154 return resultobj;
26155 fail:
26156 return NULL;
26157 }
26158
26159
26160 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26161 PyObject *resultobj = 0;
26162 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26163 wxWindow *result = 0 ;
26164 void *argp1 = 0 ;
26165 int res1 = 0 ;
26166 PyObject *swig_obj[1] ;
26167
26168 if (!args) SWIG_fail;
26169 swig_obj[0] = args;
26170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26171 if (!SWIG_IsOK(res1)) {
26172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26173 }
26174 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26175 {
26176 PyThreadState* __tstate = wxPyBeginAllowThreads();
26177 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
26178 wxPyEndAllowThreads(__tstate);
26179 if (PyErr_Occurred()) SWIG_fail;
26180 }
26181 {
26182 resultobj = wxPyMake_wxObject(result, (bool)0);
26183 }
26184 return resultobj;
26185 fail:
26186 return NULL;
26187 }
26188
26189
26190 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26191 PyObject *resultobj = 0;
26192 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26193 wxWindow *arg2 = (wxWindow *) 0 ;
26194 void *argp1 = 0 ;
26195 int res1 = 0 ;
26196 void *argp2 = 0 ;
26197 int res2 = 0 ;
26198 PyObject * obj0 = 0 ;
26199 PyObject * obj1 = 0 ;
26200 char * kwnames[] = {
26201 (char *) "self",(char *) "win", NULL
26202 };
26203
26204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
26205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26206 if (!SWIG_IsOK(res1)) {
26207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26208 }
26209 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26210 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26211 if (!SWIG_IsOK(res2)) {
26212 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
26213 }
26214 arg2 = reinterpret_cast< wxWindow * >(argp2);
26215 {
26216 PyThreadState* __tstate = wxPyBeginAllowThreads();
26217 (arg1)->SetCurrentFocus(arg2);
26218 wxPyEndAllowThreads(__tstate);
26219 if (PyErr_Occurred()) SWIG_fail;
26220 }
26221 resultobj = SWIG_Py_Void();
26222 return resultobj;
26223 fail:
26224 return NULL;
26225 }
26226
26227
26228 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26229 PyObject *obj;
26230 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26231 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
26232 return SWIG_Py_Void();
26233 }
26234
26235 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26236 return SWIG_Python_InitShadowInstance(args);
26237 }
26238
26239 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26240 PyObject *resultobj = 0;
26241 wxWindow *arg1 = (wxWindow *) NULL ;
26242 wxWindowCreateEvent *result = 0 ;
26243 void *argp1 = 0 ;
26244 int res1 = 0 ;
26245 PyObject * obj0 = 0 ;
26246 char * kwnames[] = {
26247 (char *) "win", NULL
26248 };
26249
26250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
26251 if (obj0) {
26252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26253 if (!SWIG_IsOK(res1)) {
26254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26255 }
26256 arg1 = reinterpret_cast< wxWindow * >(argp1);
26257 }
26258 {
26259 PyThreadState* __tstate = wxPyBeginAllowThreads();
26260 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
26261 wxPyEndAllowThreads(__tstate);
26262 if (PyErr_Occurred()) SWIG_fail;
26263 }
26264 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
26265 return resultobj;
26266 fail:
26267 return NULL;
26268 }
26269
26270
26271 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26272 PyObject *resultobj = 0;
26273 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
26274 wxWindow *result = 0 ;
26275 void *argp1 = 0 ;
26276 int res1 = 0 ;
26277 PyObject *swig_obj[1] ;
26278
26279 if (!args) SWIG_fail;
26280 swig_obj[0] = args;
26281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
26282 if (!SWIG_IsOK(res1)) {
26283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
26284 }
26285 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
26286 {
26287 PyThreadState* __tstate = wxPyBeginAllowThreads();
26288 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
26289 wxPyEndAllowThreads(__tstate);
26290 if (PyErr_Occurred()) SWIG_fail;
26291 }
26292 {
26293 resultobj = wxPyMake_wxObject(result, (bool)0);
26294 }
26295 return resultobj;
26296 fail:
26297 return NULL;
26298 }
26299
26300
26301 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26302 PyObject *obj;
26303 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26304 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
26305 return SWIG_Py_Void();
26306 }
26307
26308 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26309 return SWIG_Python_InitShadowInstance(args);
26310 }
26311
26312 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26313 PyObject *resultobj = 0;
26314 wxWindow *arg1 = (wxWindow *) NULL ;
26315 wxWindowDestroyEvent *result = 0 ;
26316 void *argp1 = 0 ;
26317 int res1 = 0 ;
26318 PyObject * obj0 = 0 ;
26319 char * kwnames[] = {
26320 (char *) "win", NULL
26321 };
26322
26323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
26324 if (obj0) {
26325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26326 if (!SWIG_IsOK(res1)) {
26327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26328 }
26329 arg1 = reinterpret_cast< wxWindow * >(argp1);
26330 }
26331 {
26332 PyThreadState* __tstate = wxPyBeginAllowThreads();
26333 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26334 wxPyEndAllowThreads(__tstate);
26335 if (PyErr_Occurred()) SWIG_fail;
26336 }
26337 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
26338 return resultobj;
26339 fail:
26340 return NULL;
26341 }
26342
26343
26344 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26345 PyObject *resultobj = 0;
26346 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
26347 wxWindow *result = 0 ;
26348 void *argp1 = 0 ;
26349 int res1 = 0 ;
26350 PyObject *swig_obj[1] ;
26351
26352 if (!args) SWIG_fail;
26353 swig_obj[0] = args;
26354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
26355 if (!SWIG_IsOK(res1)) {
26356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
26357 }
26358 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
26359 {
26360 PyThreadState* __tstate = wxPyBeginAllowThreads();
26361 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
26362 wxPyEndAllowThreads(__tstate);
26363 if (PyErr_Occurred()) SWIG_fail;
26364 }
26365 {
26366 resultobj = wxPyMake_wxObject(result, (bool)0);
26367 }
26368 return resultobj;
26369 fail:
26370 return NULL;
26371 }
26372
26373
26374 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26375 PyObject *obj;
26376 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26377 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
26378 return SWIG_Py_Void();
26379 }
26380
26381 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26382 return SWIG_Python_InitShadowInstance(args);
26383 }
26384
26385 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26386 PyObject *resultobj = 0;
26387 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26388 int arg2 = (int) 0 ;
26389 wxPoint const &arg3_defvalue = wxDefaultPosition ;
26390 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
26391 wxContextMenuEvent *result = 0 ;
26392 int val1 ;
26393 int ecode1 = 0 ;
26394 int val2 ;
26395 int ecode2 = 0 ;
26396 wxPoint temp3 ;
26397 PyObject * obj0 = 0 ;
26398 PyObject * obj1 = 0 ;
26399 PyObject * obj2 = 0 ;
26400 char * kwnames[] = {
26401 (char *) "type",(char *) "winid",(char *) "pt", NULL
26402 };
26403
26404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26405 if (obj0) {
26406 ecode1 = SWIG_AsVal_int(obj0, &val1);
26407 if (!SWIG_IsOK(ecode1)) {
26408 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26409 }
26410 arg1 = static_cast< wxEventType >(val1);
26411 }
26412 if (obj1) {
26413 ecode2 = SWIG_AsVal_int(obj1, &val2);
26414 if (!SWIG_IsOK(ecode2)) {
26415 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26416 }
26417 arg2 = static_cast< int >(val2);
26418 }
26419 if (obj2) {
26420 {
26421 arg3 = &temp3;
26422 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26423 }
26424 }
26425 {
26426 PyThreadState* __tstate = wxPyBeginAllowThreads();
26427 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26428 wxPyEndAllowThreads(__tstate);
26429 if (PyErr_Occurred()) SWIG_fail;
26430 }
26431 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26432 return resultobj;
26433 fail:
26434 return NULL;
26435 }
26436
26437
26438 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26439 PyObject *resultobj = 0;
26440 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26441 wxPoint *result = 0 ;
26442 void *argp1 = 0 ;
26443 int res1 = 0 ;
26444 PyObject *swig_obj[1] ;
26445
26446 if (!args) SWIG_fail;
26447 swig_obj[0] = args;
26448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26449 if (!SWIG_IsOK(res1)) {
26450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26451 }
26452 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26453 {
26454 PyThreadState* __tstate = wxPyBeginAllowThreads();
26455 {
26456 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26457 result = (wxPoint *) &_result_ref;
26458 }
26459 wxPyEndAllowThreads(__tstate);
26460 if (PyErr_Occurred()) SWIG_fail;
26461 }
26462 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26463 return resultobj;
26464 fail:
26465 return NULL;
26466 }
26467
26468
26469 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26470 PyObject *resultobj = 0;
26471 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26472 wxPoint *arg2 = 0 ;
26473 void *argp1 = 0 ;
26474 int res1 = 0 ;
26475 wxPoint temp2 ;
26476 PyObject * obj0 = 0 ;
26477 PyObject * obj1 = 0 ;
26478 char * kwnames[] = {
26479 (char *) "self",(char *) "pos", NULL
26480 };
26481
26482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26484 if (!SWIG_IsOK(res1)) {
26485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
26486 }
26487 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26488 {
26489 arg2 = &temp2;
26490 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26491 }
26492 {
26493 PyThreadState* __tstate = wxPyBeginAllowThreads();
26494 (arg1)->SetPosition((wxPoint const &)*arg2);
26495 wxPyEndAllowThreads(__tstate);
26496 if (PyErr_Occurred()) SWIG_fail;
26497 }
26498 resultobj = SWIG_Py_Void();
26499 return resultobj;
26500 fail:
26501 return NULL;
26502 }
26503
26504
26505 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26506 PyObject *obj;
26507 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26508 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
26509 return SWIG_Py_Void();
26510 }
26511
26512 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26513 return SWIG_Python_InitShadowInstance(args);
26514 }
26515
26516 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26517 PyObject *resultobj = 0;
26518 wxIdleEvent *result = 0 ;
26519
26520 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
26521 {
26522 PyThreadState* __tstate = wxPyBeginAllowThreads();
26523 result = (wxIdleEvent *)new wxIdleEvent();
26524 wxPyEndAllowThreads(__tstate);
26525 if (PyErr_Occurred()) SWIG_fail;
26526 }
26527 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
26528 return resultobj;
26529 fail:
26530 return NULL;
26531 }
26532
26533
26534 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26535 PyObject *resultobj = 0;
26536 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26537 bool arg2 = (bool) true ;
26538 void *argp1 = 0 ;
26539 int res1 = 0 ;
26540 bool val2 ;
26541 int ecode2 = 0 ;
26542 PyObject * obj0 = 0 ;
26543 PyObject * obj1 = 0 ;
26544 char * kwnames[] = {
26545 (char *) "self",(char *) "needMore", NULL
26546 };
26547
26548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
26549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26550 if (!SWIG_IsOK(res1)) {
26551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
26552 }
26553 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26554 if (obj1) {
26555 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26556 if (!SWIG_IsOK(ecode2)) {
26557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
26558 }
26559 arg2 = static_cast< bool >(val2);
26560 }
26561 {
26562 PyThreadState* __tstate = wxPyBeginAllowThreads();
26563 (arg1)->RequestMore(arg2);
26564 wxPyEndAllowThreads(__tstate);
26565 if (PyErr_Occurred()) SWIG_fail;
26566 }
26567 resultobj = SWIG_Py_Void();
26568 return resultobj;
26569 fail:
26570 return NULL;
26571 }
26572
26573
26574 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26575 PyObject *resultobj = 0;
26576 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26577 bool result;
26578 void *argp1 = 0 ;
26579 int res1 = 0 ;
26580 PyObject *swig_obj[1] ;
26581
26582 if (!args) SWIG_fail;
26583 swig_obj[0] = args;
26584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26585 if (!SWIG_IsOK(res1)) {
26586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
26587 }
26588 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26589 {
26590 PyThreadState* __tstate = wxPyBeginAllowThreads();
26591 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
26592 wxPyEndAllowThreads(__tstate);
26593 if (PyErr_Occurred()) SWIG_fail;
26594 }
26595 {
26596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26597 }
26598 return resultobj;
26599 fail:
26600 return NULL;
26601 }
26602
26603
26604 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26605 PyObject *resultobj = 0;
26606 wxIdleMode arg1 ;
26607 int val1 ;
26608 int ecode1 = 0 ;
26609 PyObject * obj0 = 0 ;
26610 char * kwnames[] = {
26611 (char *) "mode", NULL
26612 };
26613
26614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26615 ecode1 = SWIG_AsVal_int(obj0, &val1);
26616 if (!SWIG_IsOK(ecode1)) {
26617 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
26618 }
26619 arg1 = static_cast< wxIdleMode >(val1);
26620 {
26621 PyThreadState* __tstate = wxPyBeginAllowThreads();
26622 wxIdleEvent::SetMode(arg1);
26623 wxPyEndAllowThreads(__tstate);
26624 if (PyErr_Occurred()) SWIG_fail;
26625 }
26626 resultobj = SWIG_Py_Void();
26627 return resultobj;
26628 fail:
26629 return NULL;
26630 }
26631
26632
26633 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26634 PyObject *resultobj = 0;
26635 wxIdleMode result;
26636
26637 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
26638 {
26639 PyThreadState* __tstate = wxPyBeginAllowThreads();
26640 result = (wxIdleMode)wxIdleEvent::GetMode();
26641 wxPyEndAllowThreads(__tstate);
26642 if (PyErr_Occurred()) SWIG_fail;
26643 }
26644 resultobj = SWIG_From_int(static_cast< int >(result));
26645 return resultobj;
26646 fail:
26647 return NULL;
26648 }
26649
26650
26651 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26652 PyObject *resultobj = 0;
26653 wxWindow *arg1 = (wxWindow *) 0 ;
26654 bool result;
26655 void *argp1 = 0 ;
26656 int res1 = 0 ;
26657 PyObject * obj0 = 0 ;
26658 char * kwnames[] = {
26659 (char *) "win", NULL
26660 };
26661
26662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
26663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26664 if (!SWIG_IsOK(res1)) {
26665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
26666 }
26667 arg1 = reinterpret_cast< wxWindow * >(argp1);
26668 {
26669 PyThreadState* __tstate = wxPyBeginAllowThreads();
26670 result = (bool)wxIdleEvent::CanSend(arg1);
26671 wxPyEndAllowThreads(__tstate);
26672 if (PyErr_Occurred()) SWIG_fail;
26673 }
26674 {
26675 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26676 }
26677 return resultobj;
26678 fail:
26679 return NULL;
26680 }
26681
26682
26683 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26684 PyObject *obj;
26685 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26686 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
26687 return SWIG_Py_Void();
26688 }
26689
26690 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26691 return SWIG_Python_InitShadowInstance(args);
26692 }
26693
26694 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26695 PyObject *resultobj = 0;
26696 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26697 int arg2 = (int) 0 ;
26698 wxClipboardTextEvent *result = 0 ;
26699 int val1 ;
26700 int ecode1 = 0 ;
26701 int val2 ;
26702 int ecode2 = 0 ;
26703 PyObject * obj0 = 0 ;
26704 PyObject * obj1 = 0 ;
26705 char * kwnames[] = {
26706 (char *) "type",(char *) "winid", NULL
26707 };
26708
26709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26710 if (obj0) {
26711 ecode1 = SWIG_AsVal_int(obj0, &val1);
26712 if (!SWIG_IsOK(ecode1)) {
26713 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26714 }
26715 arg1 = static_cast< wxEventType >(val1);
26716 }
26717 if (obj1) {
26718 ecode2 = SWIG_AsVal_int(obj1, &val2);
26719 if (!SWIG_IsOK(ecode2)) {
26720 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
26721 }
26722 arg2 = static_cast< int >(val2);
26723 }
26724 {
26725 PyThreadState* __tstate = wxPyBeginAllowThreads();
26726 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
26727 wxPyEndAllowThreads(__tstate);
26728 if (PyErr_Occurred()) SWIG_fail;
26729 }
26730 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
26731 return resultobj;
26732 fail:
26733 return NULL;
26734 }
26735
26736
26737 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26738 PyObject *obj;
26739 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26740 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
26741 return SWIG_Py_Void();
26742 }
26743
26744 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26745 return SWIG_Python_InitShadowInstance(args);
26746 }
26747
26748 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26749 PyObject *resultobj = 0;
26750 int arg1 = (int) 0 ;
26751 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26752 wxPyEvent *result = 0 ;
26753 int val1 ;
26754 int ecode1 = 0 ;
26755 int val2 ;
26756 int ecode2 = 0 ;
26757 PyObject * obj0 = 0 ;
26758 PyObject * obj1 = 0 ;
26759 char * kwnames[] = {
26760 (char *) "winid",(char *) "eventType", NULL
26761 };
26762
26763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26764 if (obj0) {
26765 ecode1 = SWIG_AsVal_int(obj0, &val1);
26766 if (!SWIG_IsOK(ecode1)) {
26767 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26768 }
26769 arg1 = static_cast< int >(val1);
26770 }
26771 if (obj1) {
26772 ecode2 = SWIG_AsVal_int(obj1, &val2);
26773 if (!SWIG_IsOK(ecode2)) {
26774 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26775 }
26776 arg2 = static_cast< wxEventType >(val2);
26777 }
26778 {
26779 PyThreadState* __tstate = wxPyBeginAllowThreads();
26780 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26781 wxPyEndAllowThreads(__tstate);
26782 if (PyErr_Occurred()) SWIG_fail;
26783 }
26784 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26785 return resultobj;
26786 fail:
26787 return NULL;
26788 }
26789
26790
26791 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26792 PyObject *resultobj = 0;
26793 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26794 void *argp1 = 0 ;
26795 int res1 = 0 ;
26796 PyObject *swig_obj[1] ;
26797
26798 if (!args) SWIG_fail;
26799 swig_obj[0] = args;
26800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
26801 if (!SWIG_IsOK(res1)) {
26802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26803 }
26804 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26805 {
26806 PyThreadState* __tstate = wxPyBeginAllowThreads();
26807 delete arg1;
26808
26809 wxPyEndAllowThreads(__tstate);
26810 if (PyErr_Occurred()) SWIG_fail;
26811 }
26812 resultobj = SWIG_Py_Void();
26813 return resultobj;
26814 fail:
26815 return NULL;
26816 }
26817
26818
26819 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26820 PyObject *resultobj = 0;
26821 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26822 PyObject *arg2 = (PyObject *) 0 ;
26823 void *argp1 = 0 ;
26824 int res1 = 0 ;
26825 PyObject * obj0 = 0 ;
26826 PyObject * obj1 = 0 ;
26827 char * kwnames[] = {
26828 (char *) "self",(char *) "self", NULL
26829 };
26830
26831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26833 if (!SWIG_IsOK(res1)) {
26834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26835 }
26836 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26837 arg2 = obj1;
26838 {
26839 PyThreadState* __tstate = wxPyBeginAllowThreads();
26840 (arg1)->SetSelf(arg2);
26841 wxPyEndAllowThreads(__tstate);
26842 if (PyErr_Occurred()) SWIG_fail;
26843 }
26844 resultobj = SWIG_Py_Void();
26845 return resultobj;
26846 fail:
26847 return NULL;
26848 }
26849
26850
26851 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26852 PyObject *resultobj = 0;
26853 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26854 PyObject *result = 0 ;
26855 void *argp1 = 0 ;
26856 int res1 = 0 ;
26857 PyObject *swig_obj[1] ;
26858
26859 if (!args) SWIG_fail;
26860 swig_obj[0] = args;
26861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26862 if (!SWIG_IsOK(res1)) {
26863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26864 }
26865 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26866 {
26867 PyThreadState* __tstate = wxPyBeginAllowThreads();
26868 result = (PyObject *)(arg1)->GetSelf();
26869 wxPyEndAllowThreads(__tstate);
26870 if (PyErr_Occurred()) SWIG_fail;
26871 }
26872 resultobj = result;
26873 return resultobj;
26874 fail:
26875 return NULL;
26876 }
26877
26878
26879 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26880 PyObject *obj;
26881 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26882 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
26883 return SWIG_Py_Void();
26884 }
26885
26886 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26887 return SWIG_Python_InitShadowInstance(args);
26888 }
26889
26890 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26891 PyObject *resultobj = 0;
26892 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26893 int arg2 = (int) 0 ;
26894 wxPyCommandEvent *result = 0 ;
26895 int val1 ;
26896 int ecode1 = 0 ;
26897 int val2 ;
26898 int ecode2 = 0 ;
26899 PyObject * obj0 = 0 ;
26900 PyObject * obj1 = 0 ;
26901 char * kwnames[] = {
26902 (char *) "eventType",(char *) "id", NULL
26903 };
26904
26905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26906 if (obj0) {
26907 ecode1 = SWIG_AsVal_int(obj0, &val1);
26908 if (!SWIG_IsOK(ecode1)) {
26909 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26910 }
26911 arg1 = static_cast< wxEventType >(val1);
26912 }
26913 if (obj1) {
26914 ecode2 = SWIG_AsVal_int(obj1, &val2);
26915 if (!SWIG_IsOK(ecode2)) {
26916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
26917 }
26918 arg2 = static_cast< int >(val2);
26919 }
26920 {
26921 PyThreadState* __tstate = wxPyBeginAllowThreads();
26922 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
26923 wxPyEndAllowThreads(__tstate);
26924 if (PyErr_Occurred()) SWIG_fail;
26925 }
26926 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
26927 return resultobj;
26928 fail:
26929 return NULL;
26930 }
26931
26932
26933 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26934 PyObject *resultobj = 0;
26935 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26936 void *argp1 = 0 ;
26937 int res1 = 0 ;
26938 PyObject *swig_obj[1] ;
26939
26940 if (!args) SWIG_fail;
26941 swig_obj[0] = args;
26942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
26943 if (!SWIG_IsOK(res1)) {
26944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26945 }
26946 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26947 {
26948 PyThreadState* __tstate = wxPyBeginAllowThreads();
26949 delete arg1;
26950
26951 wxPyEndAllowThreads(__tstate);
26952 if (PyErr_Occurred()) SWIG_fail;
26953 }
26954 resultobj = SWIG_Py_Void();
26955 return resultobj;
26956 fail:
26957 return NULL;
26958 }
26959
26960
26961 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26962 PyObject *resultobj = 0;
26963 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26964 PyObject *arg2 = (PyObject *) 0 ;
26965 void *argp1 = 0 ;
26966 int res1 = 0 ;
26967 PyObject * obj0 = 0 ;
26968 PyObject * obj1 = 0 ;
26969 char * kwnames[] = {
26970 (char *) "self",(char *) "self", NULL
26971 };
26972
26973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26975 if (!SWIG_IsOK(res1)) {
26976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26977 }
26978 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26979 arg2 = obj1;
26980 {
26981 PyThreadState* __tstate = wxPyBeginAllowThreads();
26982 (arg1)->SetSelf(arg2);
26983 wxPyEndAllowThreads(__tstate);
26984 if (PyErr_Occurred()) SWIG_fail;
26985 }
26986 resultobj = SWIG_Py_Void();
26987 return resultobj;
26988 fail:
26989 return NULL;
26990 }
26991
26992
26993 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26994 PyObject *resultobj = 0;
26995 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26996 PyObject *result = 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_wxPyCommandEvent, 0 | 0 );
27004 if (!SWIG_IsOK(res1)) {
27005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27006 }
27007 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27008 {
27009 PyThreadState* __tstate = wxPyBeginAllowThreads();
27010 result = (PyObject *)(arg1)->GetSelf();
27011 wxPyEndAllowThreads(__tstate);
27012 if (PyErr_Occurred()) SWIG_fail;
27013 }
27014 resultobj = result;
27015 return resultobj;
27016 fail:
27017 return NULL;
27018 }
27019
27020
27021 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27022 PyObject *obj;
27023 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27024 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
27025 return SWIG_Py_Void();
27026 }
27027
27028 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27029 return SWIG_Python_InitShadowInstance(args);
27030 }
27031
27032 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27033 PyObject *resultobj = 0;
27034 wxWindow *arg1 = (wxWindow *) 0 ;
27035 wxDateTime *arg2 = 0 ;
27036 wxEventType arg3 ;
27037 wxDateEvent *result = 0 ;
27038 void *argp1 = 0 ;
27039 int res1 = 0 ;
27040 void *argp2 = 0 ;
27041 int res2 = 0 ;
27042 int val3 ;
27043 int ecode3 = 0 ;
27044 PyObject * obj0 = 0 ;
27045 PyObject * obj1 = 0 ;
27046 PyObject * obj2 = 0 ;
27047 char * kwnames[] = {
27048 (char *) "win",(char *) "dt",(char *) "type", NULL
27049 };
27050
27051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
27053 if (!SWIG_IsOK(res1)) {
27054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
27055 }
27056 arg1 = reinterpret_cast< wxWindow * >(argp1);
27057 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27058 if (!SWIG_IsOK(res2)) {
27059 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27060 }
27061 if (!argp2) {
27062 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27063 }
27064 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27065 ecode3 = SWIG_AsVal_int(obj2, &val3);
27066 if (!SWIG_IsOK(ecode3)) {
27067 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
27068 }
27069 arg3 = static_cast< wxEventType >(val3);
27070 {
27071 PyThreadState* __tstate = wxPyBeginAllowThreads();
27072 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
27073 wxPyEndAllowThreads(__tstate);
27074 if (PyErr_Occurred()) SWIG_fail;
27075 }
27076 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
27077 return resultobj;
27078 fail:
27079 return NULL;
27080 }
27081
27082
27083 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27084 PyObject *resultobj = 0;
27085 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
27086 wxDateTime *result = 0 ;
27087 void *argp1 = 0 ;
27088 int res1 = 0 ;
27089 PyObject *swig_obj[1] ;
27090
27091 if (!args) SWIG_fail;
27092 swig_obj[0] = args;
27093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27094 if (!SWIG_IsOK(res1)) {
27095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
27096 }
27097 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27098 {
27099 PyThreadState* __tstate = wxPyBeginAllowThreads();
27100 {
27101 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
27102 result = (wxDateTime *) &_result_ref;
27103 }
27104 wxPyEndAllowThreads(__tstate);
27105 if (PyErr_Occurred()) SWIG_fail;
27106 }
27107 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27108 return resultobj;
27109 fail:
27110 return NULL;
27111 }
27112
27113
27114 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27115 PyObject *resultobj = 0;
27116 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
27117 wxDateTime *arg2 = 0 ;
27118 void *argp1 = 0 ;
27119 int res1 = 0 ;
27120 void *argp2 = 0 ;
27121 int res2 = 0 ;
27122 PyObject * obj0 = 0 ;
27123 PyObject * obj1 = 0 ;
27124 char * kwnames[] = {
27125 (char *) "self",(char *) "date", NULL
27126 };
27127
27128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
27129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27130 if (!SWIG_IsOK(res1)) {
27131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
27132 }
27133 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27134 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27135 if (!SWIG_IsOK(res2)) {
27136 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27137 }
27138 if (!argp2) {
27139 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27140 }
27141 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27142 {
27143 PyThreadState* __tstate = wxPyBeginAllowThreads();
27144 (arg1)->SetDate((wxDateTime const &)*arg2);
27145 wxPyEndAllowThreads(__tstate);
27146 if (PyErr_Occurred()) SWIG_fail;
27147 }
27148 resultobj = SWIG_Py_Void();
27149 return resultobj;
27150 fail:
27151 return NULL;
27152 }
27153
27154
27155 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27156 PyObject *obj;
27157 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27158 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
27159 return SWIG_Py_Void();
27160 }
27161
27162 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27163 return SWIG_Python_InitShadowInstance(args);
27164 }
27165
27166 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27167 PyObject *resultobj = 0;
27168 wxPyApp *result = 0 ;
27169
27170 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
27171 {
27172 PyThreadState* __tstate = wxPyBeginAllowThreads();
27173 result = (wxPyApp *)new_wxPyApp();
27174 wxPyEndAllowThreads(__tstate);
27175 if (PyErr_Occurred()) SWIG_fail;
27176 }
27177 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
27178 return resultobj;
27179 fail:
27180 return NULL;
27181 }
27182
27183
27184 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27185 PyObject *resultobj = 0;
27186 wxPyApp *arg1 = (wxPyApp *) 0 ;
27187 void *argp1 = 0 ;
27188 int res1 = 0 ;
27189 PyObject *swig_obj[1] ;
27190
27191 if (!args) SWIG_fail;
27192 swig_obj[0] = args;
27193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
27194 if (!SWIG_IsOK(res1)) {
27195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
27196 }
27197 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27198 {
27199 PyThreadState* __tstate = wxPyBeginAllowThreads();
27200 delete arg1;
27201
27202 wxPyEndAllowThreads(__tstate);
27203 if (PyErr_Occurred()) SWIG_fail;
27204 }
27205 resultobj = SWIG_Py_Void();
27206 return resultobj;
27207 fail:
27208 return NULL;
27209 }
27210
27211
27212 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27213 PyObject *resultobj = 0;
27214 wxPyApp *arg1 = (wxPyApp *) 0 ;
27215 PyObject *arg2 = (PyObject *) 0 ;
27216 PyObject *arg3 = (PyObject *) 0 ;
27217 bool arg4 ;
27218 void *argp1 = 0 ;
27219 int res1 = 0 ;
27220 bool val4 ;
27221 int ecode4 = 0 ;
27222 PyObject * obj0 = 0 ;
27223 PyObject * obj1 = 0 ;
27224 PyObject * obj2 = 0 ;
27225 PyObject * obj3 = 0 ;
27226 char * kwnames[] = {
27227 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
27228 };
27229
27230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27232 if (!SWIG_IsOK(res1)) {
27233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
27234 }
27235 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27236 arg2 = obj1;
27237 arg3 = obj2;
27238 ecode4 = SWIG_AsVal_bool(obj3, &val4);
27239 if (!SWIG_IsOK(ecode4)) {
27240 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
27241 }
27242 arg4 = static_cast< bool >(val4);
27243 {
27244 PyThreadState* __tstate = wxPyBeginAllowThreads();
27245 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
27246 wxPyEndAllowThreads(__tstate);
27247 if (PyErr_Occurred()) SWIG_fail;
27248 }
27249 resultobj = SWIG_Py_Void();
27250 return resultobj;
27251 fail:
27252 return NULL;
27253 }
27254
27255
27256 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27257 PyObject *resultobj = 0;
27258 wxPyApp *arg1 = (wxPyApp *) 0 ;
27259 wxString result;
27260 void *argp1 = 0 ;
27261 int res1 = 0 ;
27262 PyObject *swig_obj[1] ;
27263
27264 if (!args) SWIG_fail;
27265 swig_obj[0] = args;
27266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27267 if (!SWIG_IsOK(res1)) {
27268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27269 }
27270 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27271 {
27272 PyThreadState* __tstate = wxPyBeginAllowThreads();
27273 result = ((wxPyApp const *)arg1)->GetAppName();
27274 wxPyEndAllowThreads(__tstate);
27275 if (PyErr_Occurred()) SWIG_fail;
27276 }
27277 {
27278 #if wxUSE_UNICODE
27279 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27280 #else
27281 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27282 #endif
27283 }
27284 return resultobj;
27285 fail:
27286 return NULL;
27287 }
27288
27289
27290 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27291 PyObject *resultobj = 0;
27292 wxPyApp *arg1 = (wxPyApp *) 0 ;
27293 wxString *arg2 = 0 ;
27294 void *argp1 = 0 ;
27295 int res1 = 0 ;
27296 bool temp2 = false ;
27297 PyObject * obj0 = 0 ;
27298 PyObject * obj1 = 0 ;
27299 char * kwnames[] = {
27300 (char *) "self",(char *) "name", NULL
27301 };
27302
27303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
27304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27305 if (!SWIG_IsOK(res1)) {
27306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27307 }
27308 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27309 {
27310 arg2 = wxString_in_helper(obj1);
27311 if (arg2 == NULL) SWIG_fail;
27312 temp2 = true;
27313 }
27314 {
27315 PyThreadState* __tstate = wxPyBeginAllowThreads();
27316 (arg1)->SetAppName((wxString const &)*arg2);
27317 wxPyEndAllowThreads(__tstate);
27318 if (PyErr_Occurred()) SWIG_fail;
27319 }
27320 resultobj = SWIG_Py_Void();
27321 {
27322 if (temp2)
27323 delete arg2;
27324 }
27325 return resultobj;
27326 fail:
27327 {
27328 if (temp2)
27329 delete arg2;
27330 }
27331 return NULL;
27332 }
27333
27334
27335 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27336 PyObject *resultobj = 0;
27337 wxPyApp *arg1 = (wxPyApp *) 0 ;
27338 wxString result;
27339 void *argp1 = 0 ;
27340 int res1 = 0 ;
27341 PyObject *swig_obj[1] ;
27342
27343 if (!args) SWIG_fail;
27344 swig_obj[0] = args;
27345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27346 if (!SWIG_IsOK(res1)) {
27347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27348 }
27349 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27350 {
27351 PyThreadState* __tstate = wxPyBeginAllowThreads();
27352 result = ((wxPyApp const *)arg1)->GetClassName();
27353 wxPyEndAllowThreads(__tstate);
27354 if (PyErr_Occurred()) SWIG_fail;
27355 }
27356 {
27357 #if wxUSE_UNICODE
27358 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27359 #else
27360 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27361 #endif
27362 }
27363 return resultobj;
27364 fail:
27365 return NULL;
27366 }
27367
27368
27369 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27370 PyObject *resultobj = 0;
27371 wxPyApp *arg1 = (wxPyApp *) 0 ;
27372 wxString *arg2 = 0 ;
27373 void *argp1 = 0 ;
27374 int res1 = 0 ;
27375 bool temp2 = false ;
27376 PyObject * obj0 = 0 ;
27377 PyObject * obj1 = 0 ;
27378 char * kwnames[] = {
27379 (char *) "self",(char *) "name", NULL
27380 };
27381
27382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
27383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27384 if (!SWIG_IsOK(res1)) {
27385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27386 }
27387 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27388 {
27389 arg2 = wxString_in_helper(obj1);
27390 if (arg2 == NULL) SWIG_fail;
27391 temp2 = true;
27392 }
27393 {
27394 PyThreadState* __tstate = wxPyBeginAllowThreads();
27395 (arg1)->SetClassName((wxString const &)*arg2);
27396 wxPyEndAllowThreads(__tstate);
27397 if (PyErr_Occurred()) SWIG_fail;
27398 }
27399 resultobj = SWIG_Py_Void();
27400 {
27401 if (temp2)
27402 delete arg2;
27403 }
27404 return resultobj;
27405 fail:
27406 {
27407 if (temp2)
27408 delete arg2;
27409 }
27410 return NULL;
27411 }
27412
27413
27414 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27415 PyObject *resultobj = 0;
27416 wxPyApp *arg1 = (wxPyApp *) 0 ;
27417 wxString *result = 0 ;
27418 void *argp1 = 0 ;
27419 int res1 = 0 ;
27420 PyObject *swig_obj[1] ;
27421
27422 if (!args) SWIG_fail;
27423 swig_obj[0] = args;
27424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27425 if (!SWIG_IsOK(res1)) {
27426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27427 }
27428 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27429 {
27430 PyThreadState* __tstate = wxPyBeginAllowThreads();
27431 {
27432 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
27433 result = (wxString *) &_result_ref;
27434 }
27435 wxPyEndAllowThreads(__tstate);
27436 if (PyErr_Occurred()) SWIG_fail;
27437 }
27438 {
27439 #if wxUSE_UNICODE
27440 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
27441 #else
27442 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
27443 #endif
27444 }
27445 return resultobj;
27446 fail:
27447 return NULL;
27448 }
27449
27450
27451 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27452 PyObject *resultobj = 0;
27453 wxPyApp *arg1 = (wxPyApp *) 0 ;
27454 wxString *arg2 = 0 ;
27455 void *argp1 = 0 ;
27456 int res1 = 0 ;
27457 bool temp2 = false ;
27458 PyObject * obj0 = 0 ;
27459 PyObject * obj1 = 0 ;
27460 char * kwnames[] = {
27461 (char *) "self",(char *) "name", NULL
27462 };
27463
27464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27466 if (!SWIG_IsOK(res1)) {
27467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27468 }
27469 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27470 {
27471 arg2 = wxString_in_helper(obj1);
27472 if (arg2 == NULL) SWIG_fail;
27473 temp2 = true;
27474 }
27475 {
27476 PyThreadState* __tstate = wxPyBeginAllowThreads();
27477 (arg1)->SetVendorName((wxString const &)*arg2);
27478 wxPyEndAllowThreads(__tstate);
27479 if (PyErr_Occurred()) SWIG_fail;
27480 }
27481 resultobj = SWIG_Py_Void();
27482 {
27483 if (temp2)
27484 delete arg2;
27485 }
27486 return resultobj;
27487 fail:
27488 {
27489 if (temp2)
27490 delete arg2;
27491 }
27492 return NULL;
27493 }
27494
27495
27496 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27497 PyObject *resultobj = 0;
27498 wxPyApp *arg1 = (wxPyApp *) 0 ;
27499 wxAppTraits *result = 0 ;
27500 void *argp1 = 0 ;
27501 int res1 = 0 ;
27502 PyObject *swig_obj[1] ;
27503
27504 if (!args) SWIG_fail;
27505 swig_obj[0] = args;
27506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27507 if (!SWIG_IsOK(res1)) {
27508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27509 }
27510 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27511 {
27512 PyThreadState* __tstate = wxPyBeginAllowThreads();
27513 result = (wxAppTraits *)(arg1)->GetTraits();
27514 wxPyEndAllowThreads(__tstate);
27515 if (PyErr_Occurred()) SWIG_fail;
27516 }
27517 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27518 return resultobj;
27519 fail:
27520 return NULL;
27521 }
27522
27523
27524 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27525 PyObject *resultobj = 0;
27526 wxPyApp *arg1 = (wxPyApp *) 0 ;
27527 void *argp1 = 0 ;
27528 int res1 = 0 ;
27529 PyObject *swig_obj[1] ;
27530
27531 if (!args) SWIG_fail;
27532 swig_obj[0] = args;
27533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27534 if (!SWIG_IsOK(res1)) {
27535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27536 }
27537 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27538 {
27539 PyThreadState* __tstate = wxPyBeginAllowThreads();
27540 (arg1)->ProcessPendingEvents();
27541 wxPyEndAllowThreads(__tstate);
27542 if (PyErr_Occurred()) SWIG_fail;
27543 }
27544 resultobj = SWIG_Py_Void();
27545 return resultobj;
27546 fail:
27547 return NULL;
27548 }
27549
27550
27551 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27552 PyObject *resultobj = 0;
27553 wxPyApp *arg1 = (wxPyApp *) 0 ;
27554 bool arg2 = (bool) false ;
27555 bool result;
27556 void *argp1 = 0 ;
27557 int res1 = 0 ;
27558 bool val2 ;
27559 int ecode2 = 0 ;
27560 PyObject * obj0 = 0 ;
27561 PyObject * obj1 = 0 ;
27562 char * kwnames[] = {
27563 (char *) "self",(char *) "onlyIfNeeded", NULL
27564 };
27565
27566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27568 if (!SWIG_IsOK(res1)) {
27569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27570 }
27571 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27572 if (obj1) {
27573 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27574 if (!SWIG_IsOK(ecode2)) {
27575 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27576 }
27577 arg2 = static_cast< bool >(val2);
27578 }
27579 {
27580 PyThreadState* __tstate = wxPyBeginAllowThreads();
27581 result = (bool)(arg1)->Yield(arg2);
27582 wxPyEndAllowThreads(__tstate);
27583 if (PyErr_Occurred()) SWIG_fail;
27584 }
27585 {
27586 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27587 }
27588 return resultobj;
27589 fail:
27590 return NULL;
27591 }
27592
27593
27594 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27595 PyObject *resultobj = 0;
27596 wxPyApp *arg1 = (wxPyApp *) 0 ;
27597 void *argp1 = 0 ;
27598 int res1 = 0 ;
27599 PyObject *swig_obj[1] ;
27600
27601 if (!args) SWIG_fail;
27602 swig_obj[0] = args;
27603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27604 if (!SWIG_IsOK(res1)) {
27605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27606 }
27607 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27608 {
27609 PyThreadState* __tstate = wxPyBeginAllowThreads();
27610 (arg1)->WakeUpIdle();
27611 wxPyEndAllowThreads(__tstate);
27612 if (PyErr_Occurred()) SWIG_fail;
27613 }
27614 resultobj = SWIG_Py_Void();
27615 return resultobj;
27616 fail:
27617 return NULL;
27618 }
27619
27620
27621 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27622 PyObject *resultobj = 0;
27623 bool result;
27624
27625 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27626 {
27627 PyThreadState* __tstate = wxPyBeginAllowThreads();
27628 result = (bool)wxPyApp::IsMainLoopRunning();
27629 wxPyEndAllowThreads(__tstate);
27630 if (PyErr_Occurred()) SWIG_fail;
27631 }
27632 {
27633 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27634 }
27635 return resultobj;
27636 fail:
27637 return NULL;
27638 }
27639
27640
27641 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27642 PyObject *resultobj = 0;
27643 wxPyApp *arg1 = (wxPyApp *) 0 ;
27644 int result;
27645 void *argp1 = 0 ;
27646 int res1 = 0 ;
27647 PyObject *swig_obj[1] ;
27648
27649 if (!args) SWIG_fail;
27650 swig_obj[0] = args;
27651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27652 if (!SWIG_IsOK(res1)) {
27653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27654 }
27655 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27656 {
27657 PyThreadState* __tstate = wxPyBeginAllowThreads();
27658 result = (int)(arg1)->MainLoop();
27659 wxPyEndAllowThreads(__tstate);
27660 if (PyErr_Occurred()) SWIG_fail;
27661 }
27662 resultobj = SWIG_From_int(static_cast< int >(result));
27663 return resultobj;
27664 fail:
27665 return NULL;
27666 }
27667
27668
27669 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27670 PyObject *resultobj = 0;
27671 wxPyApp *arg1 = (wxPyApp *) 0 ;
27672 void *argp1 = 0 ;
27673 int res1 = 0 ;
27674 PyObject *swig_obj[1] ;
27675
27676 if (!args) SWIG_fail;
27677 swig_obj[0] = args;
27678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27679 if (!SWIG_IsOK(res1)) {
27680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27681 }
27682 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27683 {
27684 PyThreadState* __tstate = wxPyBeginAllowThreads();
27685 (arg1)->Exit();
27686 wxPyEndAllowThreads(__tstate);
27687 if (PyErr_Occurred()) SWIG_fail;
27688 }
27689 resultobj = SWIG_Py_Void();
27690 return resultobj;
27691 fail:
27692 return NULL;
27693 }
27694
27695
27696 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27697 PyObject *resultobj = 0;
27698 wxPyApp *arg1 = (wxPyApp *) 0 ;
27699 void *argp1 = 0 ;
27700 int res1 = 0 ;
27701 PyObject *swig_obj[1] ;
27702
27703 if (!args) SWIG_fail;
27704 swig_obj[0] = args;
27705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27706 if (!SWIG_IsOK(res1)) {
27707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27708 }
27709 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27710 {
27711 PyThreadState* __tstate = wxPyBeginAllowThreads();
27712 (arg1)->ExitMainLoop();
27713 wxPyEndAllowThreads(__tstate);
27714 if (PyErr_Occurred()) SWIG_fail;
27715 }
27716 resultobj = SWIG_Py_Void();
27717 return resultobj;
27718 fail:
27719 return NULL;
27720 }
27721
27722
27723 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27724 PyObject *resultobj = 0;
27725 wxPyApp *arg1 = (wxPyApp *) 0 ;
27726 bool result;
27727 void *argp1 = 0 ;
27728 int res1 = 0 ;
27729 PyObject *swig_obj[1] ;
27730
27731 if (!args) SWIG_fail;
27732 swig_obj[0] = args;
27733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27734 if (!SWIG_IsOK(res1)) {
27735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27736 }
27737 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27738 {
27739 PyThreadState* __tstate = wxPyBeginAllowThreads();
27740 result = (bool)(arg1)->Pending();
27741 wxPyEndAllowThreads(__tstate);
27742 if (PyErr_Occurred()) SWIG_fail;
27743 }
27744 {
27745 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27746 }
27747 return resultobj;
27748 fail:
27749 return NULL;
27750 }
27751
27752
27753 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27754 PyObject *resultobj = 0;
27755 wxPyApp *arg1 = (wxPyApp *) 0 ;
27756 bool result;
27757 void *argp1 = 0 ;
27758 int res1 = 0 ;
27759 PyObject *swig_obj[1] ;
27760
27761 if (!args) SWIG_fail;
27762 swig_obj[0] = args;
27763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27764 if (!SWIG_IsOK(res1)) {
27765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27766 }
27767 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27768 {
27769 PyThreadState* __tstate = wxPyBeginAllowThreads();
27770 result = (bool)(arg1)->Dispatch();
27771 wxPyEndAllowThreads(__tstate);
27772 if (PyErr_Occurred()) SWIG_fail;
27773 }
27774 {
27775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27776 }
27777 return resultobj;
27778 fail:
27779 return NULL;
27780 }
27781
27782
27783 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27784 PyObject *resultobj = 0;
27785 wxPyApp *arg1 = (wxPyApp *) 0 ;
27786 bool result;
27787 void *argp1 = 0 ;
27788 int res1 = 0 ;
27789 PyObject *swig_obj[1] ;
27790
27791 if (!args) SWIG_fail;
27792 swig_obj[0] = args;
27793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27794 if (!SWIG_IsOK(res1)) {
27795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27796 }
27797 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27798 {
27799 PyThreadState* __tstate = wxPyBeginAllowThreads();
27800 result = (bool)(arg1)->ProcessIdle();
27801 wxPyEndAllowThreads(__tstate);
27802 if (PyErr_Occurred()) SWIG_fail;
27803 }
27804 {
27805 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27806 }
27807 return resultobj;
27808 fail:
27809 return NULL;
27810 }
27811
27812
27813 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27814 PyObject *resultobj = 0;
27815 wxPyApp *arg1 = (wxPyApp *) 0 ;
27816 wxWindow *arg2 = (wxWindow *) 0 ;
27817 wxIdleEvent *arg3 = 0 ;
27818 bool result;
27819 void *argp1 = 0 ;
27820 int res1 = 0 ;
27821 void *argp2 = 0 ;
27822 int res2 = 0 ;
27823 void *argp3 = 0 ;
27824 int res3 = 0 ;
27825 PyObject * obj0 = 0 ;
27826 PyObject * obj1 = 0 ;
27827 PyObject * obj2 = 0 ;
27828 char * kwnames[] = {
27829 (char *) "self",(char *) "win",(char *) "event", NULL
27830 };
27831
27832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27834 if (!SWIG_IsOK(res1)) {
27835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27836 }
27837 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27838 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27839 if (!SWIG_IsOK(res2)) {
27840 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
27841 }
27842 arg2 = reinterpret_cast< wxWindow * >(argp2);
27843 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
27844 if (!SWIG_IsOK(res3)) {
27845 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27846 }
27847 if (!argp3) {
27848 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27849 }
27850 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
27851 {
27852 PyThreadState* __tstate = wxPyBeginAllowThreads();
27853 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
27854 wxPyEndAllowThreads(__tstate);
27855 if (PyErr_Occurred()) SWIG_fail;
27856 }
27857 {
27858 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27859 }
27860 return resultobj;
27861 fail:
27862 return NULL;
27863 }
27864
27865
27866 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27867 PyObject *resultobj = 0;
27868 wxPyApp *arg1 = (wxPyApp *) 0 ;
27869 bool result;
27870 void *argp1 = 0 ;
27871 int res1 = 0 ;
27872 PyObject *swig_obj[1] ;
27873
27874 if (!args) SWIG_fail;
27875 swig_obj[0] = args;
27876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27877 if (!SWIG_IsOK(res1)) {
27878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27879 }
27880 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27881 {
27882 PyThreadState* __tstate = wxPyBeginAllowThreads();
27883 result = (bool)((wxPyApp const *)arg1)->IsActive();
27884 wxPyEndAllowThreads(__tstate);
27885 if (PyErr_Occurred()) SWIG_fail;
27886 }
27887 {
27888 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27889 }
27890 return resultobj;
27891 fail:
27892 return NULL;
27893 }
27894
27895
27896 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27897 PyObject *resultobj = 0;
27898 wxPyApp *arg1 = (wxPyApp *) 0 ;
27899 wxWindow *arg2 = (wxWindow *) 0 ;
27900 void *argp1 = 0 ;
27901 int res1 = 0 ;
27902 void *argp2 = 0 ;
27903 int res2 = 0 ;
27904 PyObject * obj0 = 0 ;
27905 PyObject * obj1 = 0 ;
27906 char * kwnames[] = {
27907 (char *) "self",(char *) "win", NULL
27908 };
27909
27910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
27911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27912 if (!SWIG_IsOK(res1)) {
27913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
27914 }
27915 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27916 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27917 if (!SWIG_IsOK(res2)) {
27918 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
27919 }
27920 arg2 = reinterpret_cast< wxWindow * >(argp2);
27921 {
27922 PyThreadState* __tstate = wxPyBeginAllowThreads();
27923 (arg1)->SetTopWindow(arg2);
27924 wxPyEndAllowThreads(__tstate);
27925 if (PyErr_Occurred()) SWIG_fail;
27926 }
27927 resultobj = SWIG_Py_Void();
27928 return resultobj;
27929 fail:
27930 return NULL;
27931 }
27932
27933
27934 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27935 PyObject *resultobj = 0;
27936 wxPyApp *arg1 = (wxPyApp *) 0 ;
27937 wxWindow *result = 0 ;
27938 void *argp1 = 0 ;
27939 int res1 = 0 ;
27940 PyObject *swig_obj[1] ;
27941
27942 if (!args) SWIG_fail;
27943 swig_obj[0] = args;
27944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27945 if (!SWIG_IsOK(res1)) {
27946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27947 }
27948 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27949 {
27950 PyThreadState* __tstate = wxPyBeginAllowThreads();
27951 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
27952 wxPyEndAllowThreads(__tstate);
27953 if (PyErr_Occurred()) SWIG_fail;
27954 }
27955 {
27956 resultobj = wxPyMake_wxObject(result, (bool)0);
27957 }
27958 return resultobj;
27959 fail:
27960 return NULL;
27961 }
27962
27963
27964 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27965 PyObject *resultobj = 0;
27966 wxPyApp *arg1 = (wxPyApp *) 0 ;
27967 bool arg2 ;
27968 void *argp1 = 0 ;
27969 int res1 = 0 ;
27970 bool val2 ;
27971 int ecode2 = 0 ;
27972 PyObject * obj0 = 0 ;
27973 PyObject * obj1 = 0 ;
27974 char * kwnames[] = {
27975 (char *) "self",(char *) "flag", NULL
27976 };
27977
27978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
27979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27980 if (!SWIG_IsOK(res1)) {
27981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
27982 }
27983 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27984 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27985 if (!SWIG_IsOK(ecode2)) {
27986 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
27987 }
27988 arg2 = static_cast< bool >(val2);
27989 {
27990 PyThreadState* __tstate = wxPyBeginAllowThreads();
27991 (arg1)->SetExitOnFrameDelete(arg2);
27992 wxPyEndAllowThreads(__tstate);
27993 if (PyErr_Occurred()) SWIG_fail;
27994 }
27995 resultobj = SWIG_Py_Void();
27996 return resultobj;
27997 fail:
27998 return NULL;
27999 }
28000
28001
28002 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28003 PyObject *resultobj = 0;
28004 wxPyApp *arg1 = (wxPyApp *) 0 ;
28005 bool result;
28006 void *argp1 = 0 ;
28007 int res1 = 0 ;
28008 PyObject *swig_obj[1] ;
28009
28010 if (!args) SWIG_fail;
28011 swig_obj[0] = args;
28012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28013 if (!SWIG_IsOK(res1)) {
28014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28015 }
28016 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28017 {
28018 PyThreadState* __tstate = wxPyBeginAllowThreads();
28019 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
28020 wxPyEndAllowThreads(__tstate);
28021 if (PyErr_Occurred()) SWIG_fail;
28022 }
28023 {
28024 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28025 }
28026 return resultobj;
28027 fail:
28028 return NULL;
28029 }
28030
28031
28032 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28033 PyObject *resultobj = 0;
28034 wxPyApp *arg1 = (wxPyApp *) 0 ;
28035 bool arg2 ;
28036 void *argp1 = 0 ;
28037 int res1 = 0 ;
28038 bool val2 ;
28039 int ecode2 = 0 ;
28040 PyObject * obj0 = 0 ;
28041 PyObject * obj1 = 0 ;
28042 char * kwnames[] = {
28043 (char *) "self",(char *) "flag", NULL
28044 };
28045
28046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
28047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28048 if (!SWIG_IsOK(res1)) {
28049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
28050 }
28051 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28052 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28053 if (!SWIG_IsOK(ecode2)) {
28054 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
28055 }
28056 arg2 = static_cast< bool >(val2);
28057 {
28058 PyThreadState* __tstate = wxPyBeginAllowThreads();
28059 (arg1)->SetUseBestVisual(arg2);
28060 wxPyEndAllowThreads(__tstate);
28061 if (PyErr_Occurred()) SWIG_fail;
28062 }
28063 resultobj = SWIG_Py_Void();
28064 return resultobj;
28065 fail:
28066 return NULL;
28067 }
28068
28069
28070 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28071 PyObject *resultobj = 0;
28072 wxPyApp *arg1 = (wxPyApp *) 0 ;
28073 bool result;
28074 void *argp1 = 0 ;
28075 int res1 = 0 ;
28076 PyObject *swig_obj[1] ;
28077
28078 if (!args) SWIG_fail;
28079 swig_obj[0] = args;
28080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28081 if (!SWIG_IsOK(res1)) {
28082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28083 }
28084 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28085 {
28086 PyThreadState* __tstate = wxPyBeginAllowThreads();
28087 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
28088 wxPyEndAllowThreads(__tstate);
28089 if (PyErr_Occurred()) SWIG_fail;
28090 }
28091 {
28092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28093 }
28094 return resultobj;
28095 fail:
28096 return NULL;
28097 }
28098
28099
28100 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28101 PyObject *resultobj = 0;
28102 wxPyApp *arg1 = (wxPyApp *) 0 ;
28103 int arg2 ;
28104 void *argp1 = 0 ;
28105 int res1 = 0 ;
28106 int val2 ;
28107 int ecode2 = 0 ;
28108 PyObject * obj0 = 0 ;
28109 PyObject * obj1 = 0 ;
28110 char * kwnames[] = {
28111 (char *) "self",(char *) "mode", NULL
28112 };
28113
28114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
28115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28116 if (!SWIG_IsOK(res1)) {
28117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28118 }
28119 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28120 ecode2 = SWIG_AsVal_int(obj1, &val2);
28121 if (!SWIG_IsOK(ecode2)) {
28122 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
28123 }
28124 arg2 = static_cast< int >(val2);
28125 {
28126 PyThreadState* __tstate = wxPyBeginAllowThreads();
28127 (arg1)->SetPrintMode(arg2);
28128 wxPyEndAllowThreads(__tstate);
28129 if (PyErr_Occurred()) SWIG_fail;
28130 }
28131 resultobj = SWIG_Py_Void();
28132 return resultobj;
28133 fail:
28134 return NULL;
28135 }
28136
28137
28138 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28139 PyObject *resultobj = 0;
28140 wxPyApp *arg1 = (wxPyApp *) 0 ;
28141 int result;
28142 void *argp1 = 0 ;
28143 int res1 = 0 ;
28144 PyObject *swig_obj[1] ;
28145
28146 if (!args) SWIG_fail;
28147 swig_obj[0] = args;
28148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28149 if (!SWIG_IsOK(res1)) {
28150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28151 }
28152 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28153 {
28154 PyThreadState* __tstate = wxPyBeginAllowThreads();
28155 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
28156 wxPyEndAllowThreads(__tstate);
28157 if (PyErr_Occurred()) SWIG_fail;
28158 }
28159 resultobj = SWIG_From_int(static_cast< int >(result));
28160 return resultobj;
28161 fail:
28162 return NULL;
28163 }
28164
28165
28166 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28167 PyObject *resultobj = 0;
28168 wxPyApp *arg1 = (wxPyApp *) 0 ;
28169 int arg2 ;
28170 void *argp1 = 0 ;
28171 int res1 = 0 ;
28172 int val2 ;
28173 int ecode2 = 0 ;
28174 PyObject * obj0 = 0 ;
28175 PyObject * obj1 = 0 ;
28176 char * kwnames[] = {
28177 (char *) "self",(char *) "mode", NULL
28178 };
28179
28180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
28181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28182 if (!SWIG_IsOK(res1)) {
28183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28184 }
28185 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28186 ecode2 = SWIG_AsVal_int(obj1, &val2);
28187 if (!SWIG_IsOK(ecode2)) {
28188 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
28189 }
28190 arg2 = static_cast< int >(val2);
28191 {
28192 PyThreadState* __tstate = wxPyBeginAllowThreads();
28193 (arg1)->SetAssertMode(arg2);
28194 wxPyEndAllowThreads(__tstate);
28195 if (PyErr_Occurred()) SWIG_fail;
28196 }
28197 resultobj = SWIG_Py_Void();
28198 return resultobj;
28199 fail:
28200 return NULL;
28201 }
28202
28203
28204 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28205 PyObject *resultobj = 0;
28206 wxPyApp *arg1 = (wxPyApp *) 0 ;
28207 int result;
28208 void *argp1 = 0 ;
28209 int res1 = 0 ;
28210 PyObject *swig_obj[1] ;
28211
28212 if (!args) SWIG_fail;
28213 swig_obj[0] = args;
28214 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28215 if (!SWIG_IsOK(res1)) {
28216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28217 }
28218 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28219 {
28220 PyThreadState* __tstate = wxPyBeginAllowThreads();
28221 result = (int)(arg1)->GetAssertMode();
28222 wxPyEndAllowThreads(__tstate);
28223 if (PyErr_Occurred()) SWIG_fail;
28224 }
28225 resultobj = SWIG_From_int(static_cast< int >(result));
28226 return resultobj;
28227 fail:
28228 return NULL;
28229 }
28230
28231
28232 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28233 PyObject *resultobj = 0;
28234 bool result;
28235
28236 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
28237 {
28238 PyThreadState* __tstate = wxPyBeginAllowThreads();
28239 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
28240 wxPyEndAllowThreads(__tstate);
28241 if (PyErr_Occurred()) SWIG_fail;
28242 }
28243 {
28244 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28245 }
28246 return resultobj;
28247 fail:
28248 return NULL;
28249 }
28250
28251
28252 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28253 PyObject *resultobj = 0;
28254 long result;
28255
28256 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
28257 {
28258 PyThreadState* __tstate = wxPyBeginAllowThreads();
28259 result = (long)wxPyApp::GetMacAboutMenuItemId();
28260 wxPyEndAllowThreads(__tstate);
28261 if (PyErr_Occurred()) SWIG_fail;
28262 }
28263 resultobj = SWIG_From_long(static_cast< long >(result));
28264 return resultobj;
28265 fail:
28266 return NULL;
28267 }
28268
28269
28270 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28271 PyObject *resultobj = 0;
28272 long result;
28273
28274 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
28275 {
28276 PyThreadState* __tstate = wxPyBeginAllowThreads();
28277 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
28278 wxPyEndAllowThreads(__tstate);
28279 if (PyErr_Occurred()) SWIG_fail;
28280 }
28281 resultobj = SWIG_From_long(static_cast< long >(result));
28282 return resultobj;
28283 fail:
28284 return NULL;
28285 }
28286
28287
28288 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28289 PyObject *resultobj = 0;
28290 long result;
28291
28292 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
28293 {
28294 PyThreadState* __tstate = wxPyBeginAllowThreads();
28295 result = (long)wxPyApp::GetMacExitMenuItemId();
28296 wxPyEndAllowThreads(__tstate);
28297 if (PyErr_Occurred()) SWIG_fail;
28298 }
28299 resultobj = SWIG_From_long(static_cast< long >(result));
28300 return resultobj;
28301 fail:
28302 return NULL;
28303 }
28304
28305
28306 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28307 PyObject *resultobj = 0;
28308 wxString result;
28309
28310 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
28311 {
28312 PyThreadState* __tstate = wxPyBeginAllowThreads();
28313 result = wxPyApp::GetMacHelpMenuTitleName();
28314 wxPyEndAllowThreads(__tstate);
28315 if (PyErr_Occurred()) SWIG_fail;
28316 }
28317 {
28318 #if wxUSE_UNICODE
28319 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28320 #else
28321 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28322 #endif
28323 }
28324 return resultobj;
28325 fail:
28326 return NULL;
28327 }
28328
28329
28330 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28331 PyObject *resultobj = 0;
28332 bool arg1 ;
28333 bool val1 ;
28334 int ecode1 = 0 ;
28335 PyObject * obj0 = 0 ;
28336 char * kwnames[] = {
28337 (char *) "val", NULL
28338 };
28339
28340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
28341 ecode1 = SWIG_AsVal_bool(obj0, &val1);
28342 if (!SWIG_IsOK(ecode1)) {
28343 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
28344 }
28345 arg1 = static_cast< bool >(val1);
28346 {
28347 PyThreadState* __tstate = wxPyBeginAllowThreads();
28348 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
28349 wxPyEndAllowThreads(__tstate);
28350 if (PyErr_Occurred()) SWIG_fail;
28351 }
28352 resultobj = SWIG_Py_Void();
28353 return resultobj;
28354 fail:
28355 return NULL;
28356 }
28357
28358
28359 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28360 PyObject *resultobj = 0;
28361 long arg1 ;
28362 long val1 ;
28363 int ecode1 = 0 ;
28364 PyObject * obj0 = 0 ;
28365 char * kwnames[] = {
28366 (char *) "val", NULL
28367 };
28368
28369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
28370 ecode1 = SWIG_AsVal_long(obj0, &val1);
28371 if (!SWIG_IsOK(ecode1)) {
28372 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
28373 }
28374 arg1 = static_cast< long >(val1);
28375 {
28376 PyThreadState* __tstate = wxPyBeginAllowThreads();
28377 wxPyApp::SetMacAboutMenuItemId(arg1);
28378 wxPyEndAllowThreads(__tstate);
28379 if (PyErr_Occurred()) SWIG_fail;
28380 }
28381 resultobj = SWIG_Py_Void();
28382 return resultobj;
28383 fail:
28384 return NULL;
28385 }
28386
28387
28388 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28389 PyObject *resultobj = 0;
28390 long arg1 ;
28391 long val1 ;
28392 int ecode1 = 0 ;
28393 PyObject * obj0 = 0 ;
28394 char * kwnames[] = {
28395 (char *) "val", NULL
28396 };
28397
28398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
28399 ecode1 = SWIG_AsVal_long(obj0, &val1);
28400 if (!SWIG_IsOK(ecode1)) {
28401 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
28402 }
28403 arg1 = static_cast< long >(val1);
28404 {
28405 PyThreadState* __tstate = wxPyBeginAllowThreads();
28406 wxPyApp::SetMacPreferencesMenuItemId(arg1);
28407 wxPyEndAllowThreads(__tstate);
28408 if (PyErr_Occurred()) SWIG_fail;
28409 }
28410 resultobj = SWIG_Py_Void();
28411 return resultobj;
28412 fail:
28413 return NULL;
28414 }
28415
28416
28417 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28418 PyObject *resultobj = 0;
28419 long arg1 ;
28420 long val1 ;
28421 int ecode1 = 0 ;
28422 PyObject * obj0 = 0 ;
28423 char * kwnames[] = {
28424 (char *) "val", NULL
28425 };
28426
28427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
28428 ecode1 = SWIG_AsVal_long(obj0, &val1);
28429 if (!SWIG_IsOK(ecode1)) {
28430 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
28431 }
28432 arg1 = static_cast< long >(val1);
28433 {
28434 PyThreadState* __tstate = wxPyBeginAllowThreads();
28435 wxPyApp::SetMacExitMenuItemId(arg1);
28436 wxPyEndAllowThreads(__tstate);
28437 if (PyErr_Occurred()) SWIG_fail;
28438 }
28439 resultobj = SWIG_Py_Void();
28440 return resultobj;
28441 fail:
28442 return NULL;
28443 }
28444
28445
28446 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28447 PyObject *resultobj = 0;
28448 wxString *arg1 = 0 ;
28449 bool temp1 = false ;
28450 PyObject * obj0 = 0 ;
28451 char * kwnames[] = {
28452 (char *) "val", NULL
28453 };
28454
28455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
28456 {
28457 arg1 = wxString_in_helper(obj0);
28458 if (arg1 == NULL) SWIG_fail;
28459 temp1 = true;
28460 }
28461 {
28462 PyThreadState* __tstate = wxPyBeginAllowThreads();
28463 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
28464 wxPyEndAllowThreads(__tstate);
28465 if (PyErr_Occurred()) SWIG_fail;
28466 }
28467 resultobj = SWIG_Py_Void();
28468 {
28469 if (temp1)
28470 delete arg1;
28471 }
28472 return resultobj;
28473 fail:
28474 {
28475 if (temp1)
28476 delete arg1;
28477 }
28478 return NULL;
28479 }
28480
28481
28482 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28483 PyObject *resultobj = 0;
28484 wxPyApp *arg1 = (wxPyApp *) 0 ;
28485 void *argp1 = 0 ;
28486 int res1 = 0 ;
28487 PyObject *swig_obj[1] ;
28488
28489 if (!args) SWIG_fail;
28490 swig_obj[0] = args;
28491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28492 if (!SWIG_IsOK(res1)) {
28493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28494 }
28495 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28496 {
28497 PyThreadState* __tstate = wxPyBeginAllowThreads();
28498 (arg1)->_BootstrapApp();
28499 wxPyEndAllowThreads(__tstate);
28500 if (PyErr_Occurred()) SWIG_fail;
28501 }
28502 resultobj = SWIG_Py_Void();
28503 return resultobj;
28504 fail:
28505 return NULL;
28506 }
28507
28508
28509 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28510 PyObject *resultobj = 0;
28511 int result;
28512
28513 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28514 {
28515 PyThreadState* __tstate = wxPyBeginAllowThreads();
28516 result = (int)wxPyApp_GetComCtl32Version();
28517 wxPyEndAllowThreads(__tstate);
28518 if (PyErr_Occurred()) SWIG_fail;
28519 }
28520 resultobj = SWIG_From_int(static_cast< int >(result));
28521 return resultobj;
28522 fail:
28523 return NULL;
28524 }
28525
28526
28527 SWIGINTERN PyObject *_wrap_PyApp_DisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28528 PyObject *resultobj = 0;
28529 bool result;
28530
28531 if (!SWIG_Python_UnpackTuple(args,"PyApp_DisplayAvailable",0,0,0)) SWIG_fail;
28532 {
28533 PyThreadState* __tstate = wxPyBeginAllowThreads();
28534 result = (bool)wxPyApp_DisplayAvailable();
28535 wxPyEndAllowThreads(__tstate);
28536 if (PyErr_Occurred()) SWIG_fail;
28537 }
28538 {
28539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28540 }
28541 return resultobj;
28542 fail:
28543 return NULL;
28544 }
28545
28546
28547 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28548 PyObject *obj;
28549 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28550 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28551 return SWIG_Py_Void();
28552 }
28553
28554 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28555 return SWIG_Python_InitShadowInstance(args);
28556 }
28557
28558 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28559 PyObject *resultobj = 0;
28560
28561 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28562 {
28563 PyThreadState* __tstate = wxPyBeginAllowThreads();
28564 wxExit();
28565 wxPyEndAllowThreads(__tstate);
28566 if (PyErr_Occurred()) SWIG_fail;
28567 }
28568 resultobj = SWIG_Py_Void();
28569 return resultobj;
28570 fail:
28571 return NULL;
28572 }
28573
28574
28575 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28576 PyObject *resultobj = 0;
28577 bool result;
28578
28579 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28580 {
28581 PyThreadState* __tstate = wxPyBeginAllowThreads();
28582 result = (bool)wxYield();
28583 wxPyEndAllowThreads(__tstate);
28584 if (PyErr_Occurred()) SWIG_fail;
28585 }
28586 {
28587 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28588 }
28589 return resultobj;
28590 fail:
28591 return NULL;
28592 }
28593
28594
28595 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28596 PyObject *resultobj = 0;
28597 bool result;
28598
28599 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28600 {
28601 PyThreadState* __tstate = wxPyBeginAllowThreads();
28602 result = (bool)wxYieldIfNeeded();
28603 wxPyEndAllowThreads(__tstate);
28604 if (PyErr_Occurred()) SWIG_fail;
28605 }
28606 {
28607 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28608 }
28609 return resultobj;
28610 fail:
28611 return NULL;
28612 }
28613
28614
28615 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28616 PyObject *resultobj = 0;
28617 wxWindow *arg1 = (wxWindow *) NULL ;
28618 bool arg2 = (bool) false ;
28619 bool result;
28620 void *argp1 = 0 ;
28621 int res1 = 0 ;
28622 bool val2 ;
28623 int ecode2 = 0 ;
28624 PyObject * obj0 = 0 ;
28625 PyObject * obj1 = 0 ;
28626 char * kwnames[] = {
28627 (char *) "win",(char *) "onlyIfNeeded", NULL
28628 };
28629
28630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28631 if (obj0) {
28632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28633 if (!SWIG_IsOK(res1)) {
28634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28635 }
28636 arg1 = reinterpret_cast< wxWindow * >(argp1);
28637 }
28638 if (obj1) {
28639 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28640 if (!SWIG_IsOK(ecode2)) {
28641 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28642 }
28643 arg2 = static_cast< bool >(val2);
28644 }
28645 {
28646 PyThreadState* __tstate = wxPyBeginAllowThreads();
28647 result = (bool)wxSafeYield(arg1,arg2);
28648 wxPyEndAllowThreads(__tstate);
28649 if (PyErr_Occurred()) SWIG_fail;
28650 }
28651 {
28652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28653 }
28654 return resultobj;
28655 fail:
28656 return NULL;
28657 }
28658
28659
28660 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28661 PyObject *resultobj = 0;
28662
28663 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28664 {
28665 PyThreadState* __tstate = wxPyBeginAllowThreads();
28666 wxWakeUpIdle();
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_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28678 PyObject *resultobj = 0;
28679 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28680 wxEvent *arg2 = 0 ;
28681 void *argp1 = 0 ;
28682 int res1 = 0 ;
28683 void *argp2 = 0 ;
28684 int res2 = 0 ;
28685 PyObject * obj0 = 0 ;
28686 PyObject * obj1 = 0 ;
28687 char * kwnames[] = {
28688 (char *) "dest",(char *) "event", NULL
28689 };
28690
28691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28693 if (!SWIG_IsOK(res1)) {
28694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28695 }
28696 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28697 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28698 if (!SWIG_IsOK(res2)) {
28699 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28700 }
28701 if (!argp2) {
28702 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28703 }
28704 arg2 = reinterpret_cast< wxEvent * >(argp2);
28705 {
28706 PyThreadState* __tstate = wxPyBeginAllowThreads();
28707 wxPostEvent(arg1,*arg2);
28708 wxPyEndAllowThreads(__tstate);
28709 if (PyErr_Occurred()) SWIG_fail;
28710 }
28711 resultobj = SWIG_Py_Void();
28712 return resultobj;
28713 fail:
28714 return NULL;
28715 }
28716
28717
28718 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28719 PyObject *resultobj = 0;
28720
28721 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28722 {
28723 PyThreadState* __tstate = wxPyBeginAllowThreads();
28724 wxApp_CleanUp();
28725 wxPyEndAllowThreads(__tstate);
28726 if (PyErr_Occurred()) SWIG_fail;
28727 }
28728 resultobj = SWIG_Py_Void();
28729 return resultobj;
28730 fail:
28731 return NULL;
28732 }
28733
28734
28735 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28736 PyObject *resultobj = 0;
28737 wxPyApp *result = 0 ;
28738
28739 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28740 {
28741 PyThreadState* __tstate = wxPyBeginAllowThreads();
28742 result = (wxPyApp *)wxPyGetApp();
28743 wxPyEndAllowThreads(__tstate);
28744 if (PyErr_Occurred()) SWIG_fail;
28745 }
28746 {
28747 resultobj = wxPyMake_wxObject(result, 0);
28748 }
28749 return resultobj;
28750 fail:
28751 return NULL;
28752 }
28753
28754
28755 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28756 PyObject *resultobj = 0;
28757 char *arg1 = (char *) 0 ;
28758 int res1 ;
28759 char *buf1 = 0 ;
28760 int alloc1 = 0 ;
28761 PyObject * obj0 = 0 ;
28762 char * kwnames[] = {
28763 (char *) "encoding", NULL
28764 };
28765
28766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28767 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
28768 if (!SWIG_IsOK(res1)) {
28769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
28770 }
28771 arg1 = buf1;
28772 {
28773 PyThreadState* __tstate = wxPyBeginAllowThreads();
28774 wxSetDefaultPyEncoding((char const *)arg1);
28775 wxPyEndAllowThreads(__tstate);
28776 if (PyErr_Occurred()) SWIG_fail;
28777 }
28778 resultobj = SWIG_Py_Void();
28779 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28780 return resultobj;
28781 fail:
28782 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28783 return NULL;
28784 }
28785
28786
28787 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28788 PyObject *resultobj = 0;
28789 char *result = 0 ;
28790
28791 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
28792 {
28793 PyThreadState* __tstate = wxPyBeginAllowThreads();
28794 result = (char *)wxGetDefaultPyEncoding();
28795 wxPyEndAllowThreads(__tstate);
28796 if (PyErr_Occurred()) SWIG_fail;
28797 }
28798 resultobj = SWIG_FromCharPtr(result);
28799 return resultobj;
28800 fail:
28801 return NULL;
28802 }
28803
28804
28805 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28806 PyObject *resultobj = 0;
28807 wxEventLoop *result = 0 ;
28808
28809 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
28810 {
28811 PyThreadState* __tstate = wxPyBeginAllowThreads();
28812 result = (wxEventLoop *)new wxEventLoop();
28813 wxPyEndAllowThreads(__tstate);
28814 if (PyErr_Occurred()) SWIG_fail;
28815 }
28816 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
28817 return resultobj;
28818 fail:
28819 return NULL;
28820 }
28821
28822
28823 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28824 PyObject *resultobj = 0;
28825 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28826 void *argp1 = 0 ;
28827 int res1 = 0 ;
28828 PyObject *swig_obj[1] ;
28829
28830 if (!args) SWIG_fail;
28831 swig_obj[0] = args;
28832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
28833 if (!SWIG_IsOK(res1)) {
28834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28835 }
28836 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28837 {
28838 PyThreadState* __tstate = wxPyBeginAllowThreads();
28839 delete arg1;
28840
28841 wxPyEndAllowThreads(__tstate);
28842 if (PyErr_Occurred()) SWIG_fail;
28843 }
28844 resultobj = SWIG_Py_Void();
28845 return resultobj;
28846 fail:
28847 return NULL;
28848 }
28849
28850
28851 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28852 PyObject *resultobj = 0;
28853 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28854 int result;
28855 void *argp1 = 0 ;
28856 int res1 = 0 ;
28857 PyObject *swig_obj[1] ;
28858
28859 if (!args) SWIG_fail;
28860 swig_obj[0] = args;
28861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28862 if (!SWIG_IsOK(res1)) {
28863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28864 }
28865 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28866 {
28867 PyThreadState* __tstate = wxPyBeginAllowThreads();
28868 result = (int)(arg1)->Run();
28869 wxPyEndAllowThreads(__tstate);
28870 if (PyErr_Occurred()) SWIG_fail;
28871 }
28872 resultobj = SWIG_From_int(static_cast< int >(result));
28873 return resultobj;
28874 fail:
28875 return NULL;
28876 }
28877
28878
28879 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28880 PyObject *resultobj = 0;
28881 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28882 int arg2 = (int) 0 ;
28883 void *argp1 = 0 ;
28884 int res1 = 0 ;
28885 int val2 ;
28886 int ecode2 = 0 ;
28887 PyObject * obj0 = 0 ;
28888 PyObject * obj1 = 0 ;
28889 char * kwnames[] = {
28890 (char *) "self",(char *) "rc", NULL
28891 };
28892
28893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
28894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28895 if (!SWIG_IsOK(res1)) {
28896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28897 }
28898 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28899 if (obj1) {
28900 ecode2 = SWIG_AsVal_int(obj1, &val2);
28901 if (!SWIG_IsOK(ecode2)) {
28902 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
28903 }
28904 arg2 = static_cast< int >(val2);
28905 }
28906 {
28907 PyThreadState* __tstate = wxPyBeginAllowThreads();
28908 (arg1)->Exit(arg2);
28909 wxPyEndAllowThreads(__tstate);
28910 if (PyErr_Occurred()) SWIG_fail;
28911 }
28912 resultobj = SWIG_Py_Void();
28913 return resultobj;
28914 fail:
28915 return NULL;
28916 }
28917
28918
28919 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28920 PyObject *resultobj = 0;
28921 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28922 bool result;
28923 void *argp1 = 0 ;
28924 int res1 = 0 ;
28925 PyObject *swig_obj[1] ;
28926
28927 if (!args) SWIG_fail;
28928 swig_obj[0] = args;
28929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28930 if (!SWIG_IsOK(res1)) {
28931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28932 }
28933 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28934 {
28935 PyThreadState* __tstate = wxPyBeginAllowThreads();
28936 result = (bool)((wxEventLoop const *)arg1)->Pending();
28937 wxPyEndAllowThreads(__tstate);
28938 if (PyErr_Occurred()) SWIG_fail;
28939 }
28940 {
28941 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28942 }
28943 return resultobj;
28944 fail:
28945 return NULL;
28946 }
28947
28948
28949 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28950 PyObject *resultobj = 0;
28951 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28952 bool result;
28953 void *argp1 = 0 ;
28954 int res1 = 0 ;
28955 PyObject *swig_obj[1] ;
28956
28957 if (!args) SWIG_fail;
28958 swig_obj[0] = args;
28959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28960 if (!SWIG_IsOK(res1)) {
28961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28962 }
28963 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28964 {
28965 PyThreadState* __tstate = wxPyBeginAllowThreads();
28966 result = (bool)(arg1)->Dispatch();
28967 wxPyEndAllowThreads(__tstate);
28968 if (PyErr_Occurred()) SWIG_fail;
28969 }
28970 {
28971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28972 }
28973 return resultobj;
28974 fail:
28975 return NULL;
28976 }
28977
28978
28979 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28980 PyObject *resultobj = 0;
28981 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28982 bool result;
28983 void *argp1 = 0 ;
28984 int res1 = 0 ;
28985 PyObject *swig_obj[1] ;
28986
28987 if (!args) SWIG_fail;
28988 swig_obj[0] = args;
28989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28990 if (!SWIG_IsOK(res1)) {
28991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28992 }
28993 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28994 {
28995 PyThreadState* __tstate = wxPyBeginAllowThreads();
28996 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
28997 wxPyEndAllowThreads(__tstate);
28998 if (PyErr_Occurred()) SWIG_fail;
28999 }
29000 {
29001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29002 }
29003 return resultobj;
29004 fail:
29005 return NULL;
29006 }
29007
29008
29009 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29010 PyObject *resultobj = 0;
29011 wxEventLoop *result = 0 ;
29012
29013 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
29014 {
29015 PyThreadState* __tstate = wxPyBeginAllowThreads();
29016 result = (wxEventLoop *)wxEventLoop::GetActive();
29017 wxPyEndAllowThreads(__tstate);
29018 if (PyErr_Occurred()) SWIG_fail;
29019 }
29020 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
29021 return resultobj;
29022 fail:
29023 return NULL;
29024 }
29025
29026
29027 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29028 PyObject *resultobj = 0;
29029 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29030 void *argp1 = 0 ;
29031 int res1 = 0 ;
29032 PyObject * obj0 = 0 ;
29033 char * kwnames[] = {
29034 (char *) "loop", NULL
29035 };
29036
29037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
29038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29039 if (!SWIG_IsOK(res1)) {
29040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29041 }
29042 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29043 {
29044 PyThreadState* __tstate = wxPyBeginAllowThreads();
29045 wxEventLoop::SetActive(arg1);
29046 wxPyEndAllowThreads(__tstate);
29047 if (PyErr_Occurred()) SWIG_fail;
29048 }
29049 resultobj = SWIG_Py_Void();
29050 return resultobj;
29051 fail:
29052 return NULL;
29053 }
29054
29055
29056 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29057 PyObject *obj;
29058 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29059 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
29060 return SWIG_Py_Void();
29061 }
29062
29063 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29064 return SWIG_Python_InitShadowInstance(args);
29065 }
29066
29067 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29068 PyObject *resultobj = 0;
29069 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29070 wxEventLoopActivator *result = 0 ;
29071 void *argp1 = 0 ;
29072 int res1 = 0 ;
29073 PyObject * obj0 = 0 ;
29074 char * kwnames[] = {
29075 (char *) "evtLoop", NULL
29076 };
29077
29078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
29079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29080 if (!SWIG_IsOK(res1)) {
29081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29082 }
29083 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29084 {
29085 PyThreadState* __tstate = wxPyBeginAllowThreads();
29086 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
29087 wxPyEndAllowThreads(__tstate);
29088 if (PyErr_Occurred()) SWIG_fail;
29089 }
29090 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
29091 return resultobj;
29092 fail:
29093 return NULL;
29094 }
29095
29096
29097 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29098 PyObject *resultobj = 0;
29099 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
29100 void *argp1 = 0 ;
29101 int res1 = 0 ;
29102 PyObject *swig_obj[1] ;
29103
29104 if (!args) SWIG_fail;
29105 swig_obj[0] = args;
29106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
29107 if (!SWIG_IsOK(res1)) {
29108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
29109 }
29110 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
29111 {
29112 PyThreadState* __tstate = wxPyBeginAllowThreads();
29113 delete arg1;
29114
29115 wxPyEndAllowThreads(__tstate);
29116 if (PyErr_Occurred()) SWIG_fail;
29117 }
29118 resultobj = SWIG_Py_Void();
29119 return resultobj;
29120 fail:
29121 return NULL;
29122 }
29123
29124
29125 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29126 PyObject *obj;
29127 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29128 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
29129 return SWIG_Py_Void();
29130 }
29131
29132 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29133 return SWIG_Python_InitShadowInstance(args);
29134 }
29135
29136 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29137 PyObject *resultobj = 0;
29138 int arg1 = (int) 0 ;
29139 int arg2 = (int) 0 ;
29140 int arg3 = (int) 0 ;
29141 wxAcceleratorEntry *result = 0 ;
29142 int val1 ;
29143 int ecode1 = 0 ;
29144 int val2 ;
29145 int ecode2 = 0 ;
29146 int val3 ;
29147 int ecode3 = 0 ;
29148 PyObject * obj0 = 0 ;
29149 PyObject * obj1 = 0 ;
29150 PyObject * obj2 = 0 ;
29151 char * kwnames[] = {
29152 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
29153 };
29154
29155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29156 if (obj0) {
29157 ecode1 = SWIG_AsVal_int(obj0, &val1);
29158 if (!SWIG_IsOK(ecode1)) {
29159 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
29160 }
29161 arg1 = static_cast< int >(val1);
29162 }
29163 if (obj1) {
29164 ecode2 = SWIG_AsVal_int(obj1, &val2);
29165 if (!SWIG_IsOK(ecode2)) {
29166 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
29167 }
29168 arg2 = static_cast< int >(val2);
29169 }
29170 if (obj2) {
29171 ecode3 = SWIG_AsVal_int(obj2, &val3);
29172 if (!SWIG_IsOK(ecode3)) {
29173 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
29174 }
29175 arg3 = static_cast< int >(val3);
29176 }
29177 {
29178 PyThreadState* __tstate = wxPyBeginAllowThreads();
29179 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
29180 wxPyEndAllowThreads(__tstate);
29181 if (PyErr_Occurred()) SWIG_fail;
29182 }
29183 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
29184 return resultobj;
29185 fail:
29186 return NULL;
29187 }
29188
29189
29190 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29191 PyObject *resultobj = 0;
29192 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29193 void *argp1 = 0 ;
29194 int res1 = 0 ;
29195 PyObject *swig_obj[1] ;
29196
29197 if (!args) SWIG_fail;
29198 swig_obj[0] = args;
29199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
29200 if (!SWIG_IsOK(res1)) {
29201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29202 }
29203 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29204 {
29205 PyThreadState* __tstate = wxPyBeginAllowThreads();
29206 delete arg1;
29207
29208 wxPyEndAllowThreads(__tstate);
29209 if (PyErr_Occurred()) SWIG_fail;
29210 }
29211 resultobj = SWIG_Py_Void();
29212 return resultobj;
29213 fail:
29214 return NULL;
29215 }
29216
29217
29218 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29219 PyObject *resultobj = 0;
29220 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29221 int arg2 ;
29222 int arg3 ;
29223 int arg4 ;
29224 void *argp1 = 0 ;
29225 int res1 = 0 ;
29226 int val2 ;
29227 int ecode2 = 0 ;
29228 int val3 ;
29229 int ecode3 = 0 ;
29230 int val4 ;
29231 int ecode4 = 0 ;
29232 PyObject * obj0 = 0 ;
29233 PyObject * obj1 = 0 ;
29234 PyObject * obj2 = 0 ;
29235 PyObject * obj3 = 0 ;
29236 char * kwnames[] = {
29237 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
29238 };
29239
29240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29242 if (!SWIG_IsOK(res1)) {
29243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29244 }
29245 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29246 ecode2 = SWIG_AsVal_int(obj1, &val2);
29247 if (!SWIG_IsOK(ecode2)) {
29248 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
29249 }
29250 arg2 = static_cast< int >(val2);
29251 ecode3 = SWIG_AsVal_int(obj2, &val3);
29252 if (!SWIG_IsOK(ecode3)) {
29253 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
29254 }
29255 arg3 = static_cast< int >(val3);
29256 ecode4 = SWIG_AsVal_int(obj3, &val4);
29257 if (!SWIG_IsOK(ecode4)) {
29258 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
29259 }
29260 arg4 = static_cast< int >(val4);
29261 {
29262 PyThreadState* __tstate = wxPyBeginAllowThreads();
29263 (arg1)->Set(arg2,arg3,arg4);
29264 wxPyEndAllowThreads(__tstate);
29265 if (PyErr_Occurred()) SWIG_fail;
29266 }
29267 resultobj = SWIG_Py_Void();
29268 return resultobj;
29269 fail:
29270 return NULL;
29271 }
29272
29273
29274 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29275 PyObject *resultobj = 0;
29276 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29277 int result;
29278 void *argp1 = 0 ;
29279 int res1 = 0 ;
29280 PyObject *swig_obj[1] ;
29281
29282 if (!args) SWIG_fail;
29283 swig_obj[0] = args;
29284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29285 if (!SWIG_IsOK(res1)) {
29286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29287 }
29288 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29289 {
29290 PyThreadState* __tstate = wxPyBeginAllowThreads();
29291 result = (int)(arg1)->GetFlags();
29292 wxPyEndAllowThreads(__tstate);
29293 if (PyErr_Occurred()) SWIG_fail;
29294 }
29295 resultobj = SWIG_From_int(static_cast< int >(result));
29296 return resultobj;
29297 fail:
29298 return NULL;
29299 }
29300
29301
29302 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29303 PyObject *resultobj = 0;
29304 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29305 int result;
29306 void *argp1 = 0 ;
29307 int res1 = 0 ;
29308 PyObject *swig_obj[1] ;
29309
29310 if (!args) SWIG_fail;
29311 swig_obj[0] = args;
29312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29313 if (!SWIG_IsOK(res1)) {
29314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29315 }
29316 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29317 {
29318 PyThreadState* __tstate = wxPyBeginAllowThreads();
29319 result = (int)(arg1)->GetKeyCode();
29320 wxPyEndAllowThreads(__tstate);
29321 if (PyErr_Occurred()) SWIG_fail;
29322 }
29323 resultobj = SWIG_From_int(static_cast< int >(result));
29324 return resultobj;
29325 fail:
29326 return NULL;
29327 }
29328
29329
29330 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29331 PyObject *resultobj = 0;
29332 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29333 int result;
29334 void *argp1 = 0 ;
29335 int res1 = 0 ;
29336 PyObject *swig_obj[1] ;
29337
29338 if (!args) SWIG_fail;
29339 swig_obj[0] = args;
29340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29341 if (!SWIG_IsOK(res1)) {
29342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29343 }
29344 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29345 {
29346 PyThreadState* __tstate = wxPyBeginAllowThreads();
29347 result = (int)(arg1)->GetCommand();
29348 wxPyEndAllowThreads(__tstate);
29349 if (PyErr_Occurred()) SWIG_fail;
29350 }
29351 resultobj = SWIG_From_int(static_cast< int >(result));
29352 return resultobj;
29353 fail:
29354 return NULL;
29355 }
29356
29357
29358 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29359 PyObject *obj;
29360 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29361 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
29362 return SWIG_Py_Void();
29363 }
29364
29365 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29366 return SWIG_Python_InitShadowInstance(args);
29367 }
29368
29369 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29370 PyObject *resultobj = 0;
29371 int arg1 ;
29372 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
29373 wxAcceleratorTable *result = 0 ;
29374 PyObject * obj0 = 0 ;
29375 char * kwnames[] = {
29376 (char *) "n", NULL
29377 };
29378
29379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
29380 {
29381 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
29382 if (arg2) arg1 = PyList_Size(obj0);
29383 else arg1 = 0;
29384 }
29385 {
29386 PyThreadState* __tstate = wxPyBeginAllowThreads();
29387 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
29388 wxPyEndAllowThreads(__tstate);
29389 if (PyErr_Occurred()) SWIG_fail;
29390 }
29391 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
29392 return resultobj;
29393 fail:
29394 return NULL;
29395 }
29396
29397
29398 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29399 PyObject *resultobj = 0;
29400 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29401 void *argp1 = 0 ;
29402 int res1 = 0 ;
29403 PyObject *swig_obj[1] ;
29404
29405 if (!args) SWIG_fail;
29406 swig_obj[0] = args;
29407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
29408 if (!SWIG_IsOK(res1)) {
29409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
29410 }
29411 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29412 {
29413 PyThreadState* __tstate = wxPyBeginAllowThreads();
29414 delete arg1;
29415
29416 wxPyEndAllowThreads(__tstate);
29417 if (PyErr_Occurred()) SWIG_fail;
29418 }
29419 resultobj = SWIG_Py_Void();
29420 return resultobj;
29421 fail:
29422 return NULL;
29423 }
29424
29425
29426 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29427 PyObject *resultobj = 0;
29428 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29429 bool result;
29430 void *argp1 = 0 ;
29431 int res1 = 0 ;
29432 PyObject *swig_obj[1] ;
29433
29434 if (!args) SWIG_fail;
29435 swig_obj[0] = args;
29436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
29437 if (!SWIG_IsOK(res1)) {
29438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
29439 }
29440 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29441 {
29442 PyThreadState* __tstate = wxPyBeginAllowThreads();
29443 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
29444 wxPyEndAllowThreads(__tstate);
29445 if (PyErr_Occurred()) SWIG_fail;
29446 }
29447 {
29448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29449 }
29450 return resultobj;
29451 fail:
29452 return NULL;
29453 }
29454
29455
29456 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29457 PyObject *obj;
29458 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29459 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
29460 return SWIG_Py_Void();
29461 }
29462
29463 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29464 return SWIG_Python_InitShadowInstance(args);
29465 }
29466
29467 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
29468 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
29469 return 1;
29470 }
29471
29472
29473 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
29474 PyObject *pyobj = 0;
29475
29476 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
29477 return pyobj;
29478 }
29479
29480
29481 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29482 PyObject *resultobj = 0;
29483 wxString *arg1 = 0 ;
29484 wxAcceleratorEntry *result = 0 ;
29485 bool temp1 = false ;
29486 PyObject * obj0 = 0 ;
29487 char * kwnames[] = {
29488 (char *) "label", NULL
29489 };
29490
29491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
29492 {
29493 arg1 = wxString_in_helper(obj0);
29494 if (arg1 == NULL) SWIG_fail;
29495 temp1 = true;
29496 }
29497 {
29498 PyThreadState* __tstate = wxPyBeginAllowThreads();
29499 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29500 wxPyEndAllowThreads(__tstate);
29501 if (PyErr_Occurred()) SWIG_fail;
29502 }
29503 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29504 {
29505 if (temp1)
29506 delete arg1;
29507 }
29508 return resultobj;
29509 fail:
29510 {
29511 if (temp1)
29512 delete arg1;
29513 }
29514 return NULL;
29515 }
29516
29517
29518 SWIGINTERN int PanelNameStr_set(PyObject *) {
29519 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29520 return 1;
29521 }
29522
29523
29524 SWIGINTERN PyObject *PanelNameStr_get(void) {
29525 PyObject *pyobj = 0;
29526
29527 {
29528 #if wxUSE_UNICODE
29529 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29530 #else
29531 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29532 #endif
29533 }
29534 return pyobj;
29535 }
29536
29537
29538 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29539 PyObject *resultobj = 0;
29540 wxVisualAttributes *result = 0 ;
29541
29542 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29543 {
29544 PyThreadState* __tstate = wxPyBeginAllowThreads();
29545 result = (wxVisualAttributes *)new_wxVisualAttributes();
29546 wxPyEndAllowThreads(__tstate);
29547 if (PyErr_Occurred()) SWIG_fail;
29548 }
29549 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29550 return resultobj;
29551 fail:
29552 return NULL;
29553 }
29554
29555
29556 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29557 PyObject *resultobj = 0;
29558 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29559 void *argp1 = 0 ;
29560 int res1 = 0 ;
29561 PyObject *swig_obj[1] ;
29562
29563 if (!args) SWIG_fail;
29564 swig_obj[0] = args;
29565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29566 if (!SWIG_IsOK(res1)) {
29567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29568 }
29569 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29570 {
29571 PyThreadState* __tstate = wxPyBeginAllowThreads();
29572 delete_wxVisualAttributes(arg1);
29573
29574 wxPyEndAllowThreads(__tstate);
29575 if (PyErr_Occurred()) SWIG_fail;
29576 }
29577 resultobj = SWIG_Py_Void();
29578 return resultobj;
29579 fail:
29580 return NULL;
29581 }
29582
29583
29584 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29585 PyObject *resultobj = 0;
29586 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29587 wxFont *arg2 = (wxFont *) 0 ;
29588 void *argp1 = 0 ;
29589 int res1 = 0 ;
29590 void *argp2 = 0 ;
29591 int res2 = 0 ;
29592 PyObject *swig_obj[2] ;
29593
29594 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29596 if (!SWIG_IsOK(res1)) {
29597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29598 }
29599 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29600 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29601 if (!SWIG_IsOK(res2)) {
29602 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29603 }
29604 arg2 = reinterpret_cast< wxFont * >(argp2);
29605 if (arg1) (arg1)->font = *arg2;
29606
29607 resultobj = SWIG_Py_Void();
29608 return resultobj;
29609 fail:
29610 return NULL;
29611 }
29612
29613
29614 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29615 PyObject *resultobj = 0;
29616 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29617 wxFont *result = 0 ;
29618 void *argp1 = 0 ;
29619 int res1 = 0 ;
29620 PyObject *swig_obj[1] ;
29621
29622 if (!args) SWIG_fail;
29623 swig_obj[0] = args;
29624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29625 if (!SWIG_IsOK(res1)) {
29626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29627 }
29628 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29629 result = (wxFont *)& ((arg1)->font);
29630 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
29631 return resultobj;
29632 fail:
29633 return NULL;
29634 }
29635
29636
29637 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29638 PyObject *resultobj = 0;
29639 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29640 wxColour *arg2 = (wxColour *) 0 ;
29641 void *argp1 = 0 ;
29642 int res1 = 0 ;
29643 void *argp2 = 0 ;
29644 int res2 = 0 ;
29645 PyObject *swig_obj[2] ;
29646
29647 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
29648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29649 if (!SWIG_IsOK(res1)) {
29650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29651 }
29652 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29653 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29654 if (!SWIG_IsOK(res2)) {
29655 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29656 }
29657 arg2 = reinterpret_cast< wxColour * >(argp2);
29658 if (arg1) (arg1)->colFg = *arg2;
29659
29660 resultobj = SWIG_Py_Void();
29661 return resultobj;
29662 fail:
29663 return NULL;
29664 }
29665
29666
29667 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29668 PyObject *resultobj = 0;
29669 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29670 wxColour *result = 0 ;
29671 void *argp1 = 0 ;
29672 int res1 = 0 ;
29673 PyObject *swig_obj[1] ;
29674
29675 if (!args) SWIG_fail;
29676 swig_obj[0] = args;
29677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29678 if (!SWIG_IsOK(res1)) {
29679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29680 }
29681 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29682 result = (wxColour *)& ((arg1)->colFg);
29683 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29684 return resultobj;
29685 fail:
29686 return NULL;
29687 }
29688
29689
29690 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29691 PyObject *resultobj = 0;
29692 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29693 wxColour *arg2 = (wxColour *) 0 ;
29694 void *argp1 = 0 ;
29695 int res1 = 0 ;
29696 void *argp2 = 0 ;
29697 int res2 = 0 ;
29698 PyObject *swig_obj[2] ;
29699
29700 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
29701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29702 if (!SWIG_IsOK(res1)) {
29703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29704 }
29705 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29706 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29707 if (!SWIG_IsOK(res2)) {
29708 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29709 }
29710 arg2 = reinterpret_cast< wxColour * >(argp2);
29711 if (arg1) (arg1)->colBg = *arg2;
29712
29713 resultobj = SWIG_Py_Void();
29714 return resultobj;
29715 fail:
29716 return NULL;
29717 }
29718
29719
29720 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29721 PyObject *resultobj = 0;
29722 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29723 wxColour *result = 0 ;
29724 void *argp1 = 0 ;
29725 int res1 = 0 ;
29726 PyObject *swig_obj[1] ;
29727
29728 if (!args) SWIG_fail;
29729 swig_obj[0] = args;
29730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29731 if (!SWIG_IsOK(res1)) {
29732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29733 }
29734 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29735 result = (wxColour *)& ((arg1)->colBg);
29736 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29737 return resultobj;
29738 fail:
29739 return NULL;
29740 }
29741
29742
29743 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29744 PyObject *obj;
29745 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29746 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
29747 return SWIG_Py_Void();
29748 }
29749
29750 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29751 return SWIG_Python_InitShadowInstance(args);
29752 }
29753
29754 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29755 PyObject *resultobj = 0;
29756 wxWindow *arg1 = (wxWindow *) 0 ;
29757 int arg2 = (int) (int)-1 ;
29758 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29759 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29760 wxSize const &arg4_defvalue = wxDefaultSize ;
29761 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
29762 long arg5 = (long) 0 ;
29763 wxString const &arg6_defvalue = wxPyPanelNameStr ;
29764 wxString *arg6 = (wxString *) &arg6_defvalue ;
29765 wxWindow *result = 0 ;
29766 void *argp1 = 0 ;
29767 int res1 = 0 ;
29768 int val2 ;
29769 int ecode2 = 0 ;
29770 wxPoint temp3 ;
29771 wxSize temp4 ;
29772 long val5 ;
29773 int ecode5 = 0 ;
29774 bool temp6 = false ;
29775 PyObject * obj0 = 0 ;
29776 PyObject * obj1 = 0 ;
29777 PyObject * obj2 = 0 ;
29778 PyObject * obj3 = 0 ;
29779 PyObject * obj4 = 0 ;
29780 PyObject * obj5 = 0 ;
29781 char * kwnames[] = {
29782 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29783 };
29784
29785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
29786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29787 if (!SWIG_IsOK(res1)) {
29788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
29789 }
29790 arg1 = reinterpret_cast< wxWindow * >(argp1);
29791 if (obj1) {
29792 ecode2 = SWIG_AsVal_int(obj1, &val2);
29793 if (!SWIG_IsOK(ecode2)) {
29794 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
29795 }
29796 arg2 = static_cast< int >(val2);
29797 }
29798 if (obj2) {
29799 {
29800 arg3 = &temp3;
29801 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29802 }
29803 }
29804 if (obj3) {
29805 {
29806 arg4 = &temp4;
29807 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
29808 }
29809 }
29810 if (obj4) {
29811 ecode5 = SWIG_AsVal_long(obj4, &val5);
29812 if (!SWIG_IsOK(ecode5)) {
29813 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
29814 }
29815 arg5 = static_cast< long >(val5);
29816 }
29817 if (obj5) {
29818 {
29819 arg6 = wxString_in_helper(obj5);
29820 if (arg6 == NULL) SWIG_fail;
29821 temp6 = true;
29822 }
29823 }
29824 {
29825 if (!wxPyCheckForApp()) SWIG_fail;
29826 PyThreadState* __tstate = wxPyBeginAllowThreads();
29827 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
29828 wxPyEndAllowThreads(__tstate);
29829 if (PyErr_Occurred()) SWIG_fail;
29830 }
29831 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
29832 {
29833 if (temp6)
29834 delete arg6;
29835 }
29836 return resultobj;
29837 fail:
29838 {
29839 if (temp6)
29840 delete arg6;
29841 }
29842 return NULL;
29843 }
29844
29845
29846 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29847 PyObject *resultobj = 0;
29848 wxWindow *result = 0 ;
29849
29850 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
29851 {
29852 if (!wxPyCheckForApp()) SWIG_fail;
29853 PyThreadState* __tstate = wxPyBeginAllowThreads();
29854 result = (wxWindow *)new wxWindow();
29855 wxPyEndAllowThreads(__tstate);
29856 if (PyErr_Occurred()) SWIG_fail;
29857 }
29858 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
29859 return resultobj;
29860 fail:
29861 return NULL;
29862 }
29863
29864
29865 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29866 PyObject *resultobj = 0;
29867 wxWindow *arg1 = (wxWindow *) 0 ;
29868 wxWindow *arg2 = (wxWindow *) 0 ;
29869 int arg3 = (int) (int)-1 ;
29870 wxPoint const &arg4_defvalue = wxDefaultPosition ;
29871 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
29872 wxSize const &arg5_defvalue = wxDefaultSize ;
29873 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
29874 long arg6 = (long) 0 ;
29875 wxString const &arg7_defvalue = wxPyPanelNameStr ;
29876 wxString *arg7 = (wxString *) &arg7_defvalue ;
29877 bool result;
29878 void *argp1 = 0 ;
29879 int res1 = 0 ;
29880 void *argp2 = 0 ;
29881 int res2 = 0 ;
29882 int val3 ;
29883 int ecode3 = 0 ;
29884 wxPoint temp4 ;
29885 wxSize temp5 ;
29886 long val6 ;
29887 int ecode6 = 0 ;
29888 bool temp7 = false ;
29889 PyObject * obj0 = 0 ;
29890 PyObject * obj1 = 0 ;
29891 PyObject * obj2 = 0 ;
29892 PyObject * obj3 = 0 ;
29893 PyObject * obj4 = 0 ;
29894 PyObject * obj5 = 0 ;
29895 PyObject * obj6 = 0 ;
29896 char * kwnames[] = {
29897 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29898 };
29899
29900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
29901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29902 if (!SWIG_IsOK(res1)) {
29903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
29904 }
29905 arg1 = reinterpret_cast< wxWindow * >(argp1);
29906 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29907 if (!SWIG_IsOK(res2)) {
29908 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
29909 }
29910 arg2 = reinterpret_cast< wxWindow * >(argp2);
29911 if (obj2) {
29912 ecode3 = SWIG_AsVal_int(obj2, &val3);
29913 if (!SWIG_IsOK(ecode3)) {
29914 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
29915 }
29916 arg3 = static_cast< int >(val3);
29917 }
29918 if (obj3) {
29919 {
29920 arg4 = &temp4;
29921 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
29922 }
29923 }
29924 if (obj4) {
29925 {
29926 arg5 = &temp5;
29927 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
29928 }
29929 }
29930 if (obj5) {
29931 ecode6 = SWIG_AsVal_long(obj5, &val6);
29932 if (!SWIG_IsOK(ecode6)) {
29933 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
29934 }
29935 arg6 = static_cast< long >(val6);
29936 }
29937 if (obj6) {
29938 {
29939 arg7 = wxString_in_helper(obj6);
29940 if (arg7 == NULL) SWIG_fail;
29941 temp7 = true;
29942 }
29943 }
29944 {
29945 PyThreadState* __tstate = wxPyBeginAllowThreads();
29946 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
29947 wxPyEndAllowThreads(__tstate);
29948 if (PyErr_Occurred()) SWIG_fail;
29949 }
29950 {
29951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29952 }
29953 {
29954 if (temp7)
29955 delete arg7;
29956 }
29957 return resultobj;
29958 fail:
29959 {
29960 if (temp7)
29961 delete arg7;
29962 }
29963 return NULL;
29964 }
29965
29966
29967 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29968 PyObject *resultobj = 0;
29969 wxWindow *arg1 = (wxWindow *) 0 ;
29970 bool arg2 = (bool) false ;
29971 bool result;
29972 void *argp1 = 0 ;
29973 int res1 = 0 ;
29974 bool val2 ;
29975 int ecode2 = 0 ;
29976 PyObject * obj0 = 0 ;
29977 PyObject * obj1 = 0 ;
29978 char * kwnames[] = {
29979 (char *) "self",(char *) "force", NULL
29980 };
29981
29982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
29983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29984 if (!SWIG_IsOK(res1)) {
29985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
29986 }
29987 arg1 = reinterpret_cast< wxWindow * >(argp1);
29988 if (obj1) {
29989 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29990 if (!SWIG_IsOK(ecode2)) {
29991 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
29992 }
29993 arg2 = static_cast< bool >(val2);
29994 }
29995 {
29996 PyThreadState* __tstate = wxPyBeginAllowThreads();
29997 result = (bool)(arg1)->Close(arg2);
29998 wxPyEndAllowThreads(__tstate);
29999 if (PyErr_Occurred()) SWIG_fail;
30000 }
30001 {
30002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30003 }
30004 return resultobj;
30005 fail:
30006 return NULL;
30007 }
30008
30009
30010 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30011 PyObject *resultobj = 0;
30012 wxWindow *arg1 = (wxWindow *) 0 ;
30013 bool result;
30014 void *argp1 = 0 ;
30015 int res1 = 0 ;
30016 PyObject *swig_obj[1] ;
30017
30018 if (!args) SWIG_fail;
30019 swig_obj[0] = args;
30020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30021 if (!SWIG_IsOK(res1)) {
30022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
30023 }
30024 arg1 = reinterpret_cast< wxWindow * >(argp1);
30025 {
30026 PyThreadState* __tstate = wxPyBeginAllowThreads();
30027 result = (bool)(arg1)->Destroy();
30028 wxPyEndAllowThreads(__tstate);
30029 if (PyErr_Occurred()) SWIG_fail;
30030 }
30031 {
30032 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30033 }
30034 return resultobj;
30035 fail:
30036 return NULL;
30037 }
30038
30039
30040 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30041 PyObject *resultobj = 0;
30042 wxWindow *arg1 = (wxWindow *) 0 ;
30043 bool result;
30044 void *argp1 = 0 ;
30045 int res1 = 0 ;
30046 PyObject *swig_obj[1] ;
30047
30048 if (!args) SWIG_fail;
30049 swig_obj[0] = args;
30050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30051 if (!SWIG_IsOK(res1)) {
30052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
30053 }
30054 arg1 = reinterpret_cast< wxWindow * >(argp1);
30055 {
30056 PyThreadState* __tstate = wxPyBeginAllowThreads();
30057 result = (bool)(arg1)->DestroyChildren();
30058 wxPyEndAllowThreads(__tstate);
30059 if (PyErr_Occurred()) SWIG_fail;
30060 }
30061 {
30062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30063 }
30064 return resultobj;
30065 fail:
30066 return NULL;
30067 }
30068
30069
30070 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30071 PyObject *resultobj = 0;
30072 wxWindow *arg1 = (wxWindow *) 0 ;
30073 bool result;
30074 void *argp1 = 0 ;
30075 int res1 = 0 ;
30076 PyObject *swig_obj[1] ;
30077
30078 if (!args) SWIG_fail;
30079 swig_obj[0] = args;
30080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30081 if (!SWIG_IsOK(res1)) {
30082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
30083 }
30084 arg1 = reinterpret_cast< wxWindow * >(argp1);
30085 {
30086 PyThreadState* __tstate = wxPyBeginAllowThreads();
30087 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
30088 wxPyEndAllowThreads(__tstate);
30089 if (PyErr_Occurred()) SWIG_fail;
30090 }
30091 {
30092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30093 }
30094 return resultobj;
30095 fail:
30096 return NULL;
30097 }
30098
30099
30100 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30101 PyObject *resultobj = 0;
30102 wxWindow *arg1 = (wxWindow *) 0 ;
30103 wxString *arg2 = 0 ;
30104 void *argp1 = 0 ;
30105 int res1 = 0 ;
30106 bool temp2 = false ;
30107 PyObject * obj0 = 0 ;
30108 PyObject * obj1 = 0 ;
30109 char * kwnames[] = {
30110 (char *) "self",(char *) "label", NULL
30111 };
30112
30113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
30114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30115 if (!SWIG_IsOK(res1)) {
30116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
30117 }
30118 arg1 = reinterpret_cast< wxWindow * >(argp1);
30119 {
30120 arg2 = wxString_in_helper(obj1);
30121 if (arg2 == NULL) SWIG_fail;
30122 temp2 = true;
30123 }
30124 {
30125 PyThreadState* __tstate = wxPyBeginAllowThreads();
30126 (arg1)->SetLabel((wxString const &)*arg2);
30127 wxPyEndAllowThreads(__tstate);
30128 if (PyErr_Occurred()) SWIG_fail;
30129 }
30130 resultobj = SWIG_Py_Void();
30131 {
30132 if (temp2)
30133 delete arg2;
30134 }
30135 return resultobj;
30136 fail:
30137 {
30138 if (temp2)
30139 delete arg2;
30140 }
30141 return NULL;
30142 }
30143
30144
30145 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30146 PyObject *resultobj = 0;
30147 wxWindow *arg1 = (wxWindow *) 0 ;
30148 wxString result;
30149 void *argp1 = 0 ;
30150 int res1 = 0 ;
30151 PyObject *swig_obj[1] ;
30152
30153 if (!args) SWIG_fail;
30154 swig_obj[0] = args;
30155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30156 if (!SWIG_IsOK(res1)) {
30157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
30158 }
30159 arg1 = reinterpret_cast< wxWindow * >(argp1);
30160 {
30161 PyThreadState* __tstate = wxPyBeginAllowThreads();
30162 result = ((wxWindow const *)arg1)->GetLabel();
30163 wxPyEndAllowThreads(__tstate);
30164 if (PyErr_Occurred()) SWIG_fail;
30165 }
30166 {
30167 #if wxUSE_UNICODE
30168 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30169 #else
30170 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30171 #endif
30172 }
30173 return resultobj;
30174 fail:
30175 return NULL;
30176 }
30177
30178
30179 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30180 PyObject *resultobj = 0;
30181 wxWindow *arg1 = (wxWindow *) 0 ;
30182 wxString *arg2 = 0 ;
30183 void *argp1 = 0 ;
30184 int res1 = 0 ;
30185 bool temp2 = false ;
30186 PyObject * obj0 = 0 ;
30187 PyObject * obj1 = 0 ;
30188 char * kwnames[] = {
30189 (char *) "self",(char *) "name", NULL
30190 };
30191
30192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
30193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30194 if (!SWIG_IsOK(res1)) {
30195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
30196 }
30197 arg1 = reinterpret_cast< wxWindow * >(argp1);
30198 {
30199 arg2 = wxString_in_helper(obj1);
30200 if (arg2 == NULL) SWIG_fail;
30201 temp2 = true;
30202 }
30203 {
30204 PyThreadState* __tstate = wxPyBeginAllowThreads();
30205 (arg1)->SetName((wxString const &)*arg2);
30206 wxPyEndAllowThreads(__tstate);
30207 if (PyErr_Occurred()) SWIG_fail;
30208 }
30209 resultobj = SWIG_Py_Void();
30210 {
30211 if (temp2)
30212 delete arg2;
30213 }
30214 return resultobj;
30215 fail:
30216 {
30217 if (temp2)
30218 delete arg2;
30219 }
30220 return NULL;
30221 }
30222
30223
30224 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30225 PyObject *resultobj = 0;
30226 wxWindow *arg1 = (wxWindow *) 0 ;
30227 wxString result;
30228 void *argp1 = 0 ;
30229 int res1 = 0 ;
30230 PyObject *swig_obj[1] ;
30231
30232 if (!args) SWIG_fail;
30233 swig_obj[0] = args;
30234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30235 if (!SWIG_IsOK(res1)) {
30236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
30237 }
30238 arg1 = reinterpret_cast< wxWindow * >(argp1);
30239 {
30240 PyThreadState* __tstate = wxPyBeginAllowThreads();
30241 result = ((wxWindow const *)arg1)->GetName();
30242 wxPyEndAllowThreads(__tstate);
30243 if (PyErr_Occurred()) SWIG_fail;
30244 }
30245 {
30246 #if wxUSE_UNICODE
30247 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30248 #else
30249 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30250 #endif
30251 }
30252 return resultobj;
30253 fail:
30254 return NULL;
30255 }
30256
30257
30258 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30259 PyObject *resultobj = 0;
30260 wxWindow *arg1 = (wxWindow *) 0 ;
30261 wxWindowVariant arg2 ;
30262 void *argp1 = 0 ;
30263 int res1 = 0 ;
30264 int val2 ;
30265 int ecode2 = 0 ;
30266 PyObject * obj0 = 0 ;
30267 PyObject * obj1 = 0 ;
30268 char * kwnames[] = {
30269 (char *) "self",(char *) "variant", NULL
30270 };
30271
30272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
30273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30274 if (!SWIG_IsOK(res1)) {
30275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
30276 }
30277 arg1 = reinterpret_cast< wxWindow * >(argp1);
30278 ecode2 = SWIG_AsVal_int(obj1, &val2);
30279 if (!SWIG_IsOK(ecode2)) {
30280 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
30281 }
30282 arg2 = static_cast< wxWindowVariant >(val2);
30283 {
30284 PyThreadState* __tstate = wxPyBeginAllowThreads();
30285 (arg1)->SetWindowVariant(arg2);
30286 wxPyEndAllowThreads(__tstate);
30287 if (PyErr_Occurred()) SWIG_fail;
30288 }
30289 resultobj = SWIG_Py_Void();
30290 return resultobj;
30291 fail:
30292 return NULL;
30293 }
30294
30295
30296 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30297 PyObject *resultobj = 0;
30298 wxWindow *arg1 = (wxWindow *) 0 ;
30299 wxWindowVariant result;
30300 void *argp1 = 0 ;
30301 int res1 = 0 ;
30302 PyObject *swig_obj[1] ;
30303
30304 if (!args) SWIG_fail;
30305 swig_obj[0] = args;
30306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30307 if (!SWIG_IsOK(res1)) {
30308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
30309 }
30310 arg1 = reinterpret_cast< wxWindow * >(argp1);
30311 {
30312 PyThreadState* __tstate = wxPyBeginAllowThreads();
30313 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
30314 wxPyEndAllowThreads(__tstate);
30315 if (PyErr_Occurred()) SWIG_fail;
30316 }
30317 resultobj = SWIG_From_int(static_cast< int >(result));
30318 return resultobj;
30319 fail:
30320 return NULL;
30321 }
30322
30323
30324 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30325 PyObject *resultobj = 0;
30326 wxWindow *arg1 = (wxWindow *) 0 ;
30327 int arg2 ;
30328 void *argp1 = 0 ;
30329 int res1 = 0 ;
30330 int val2 ;
30331 int ecode2 = 0 ;
30332 PyObject * obj0 = 0 ;
30333 PyObject * obj1 = 0 ;
30334 char * kwnames[] = {
30335 (char *) "self",(char *) "winid", NULL
30336 };
30337
30338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30340 if (!SWIG_IsOK(res1)) {
30341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
30342 }
30343 arg1 = reinterpret_cast< wxWindow * >(argp1);
30344 ecode2 = SWIG_AsVal_int(obj1, &val2);
30345 if (!SWIG_IsOK(ecode2)) {
30346 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
30347 }
30348 arg2 = static_cast< int >(val2);
30349 {
30350 PyThreadState* __tstate = wxPyBeginAllowThreads();
30351 (arg1)->SetId(arg2);
30352 wxPyEndAllowThreads(__tstate);
30353 if (PyErr_Occurred()) SWIG_fail;
30354 }
30355 resultobj = SWIG_Py_Void();
30356 return resultobj;
30357 fail:
30358 return NULL;
30359 }
30360
30361
30362 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30363 PyObject *resultobj = 0;
30364 wxWindow *arg1 = (wxWindow *) 0 ;
30365 int result;
30366 void *argp1 = 0 ;
30367 int res1 = 0 ;
30368 PyObject *swig_obj[1] ;
30369
30370 if (!args) SWIG_fail;
30371 swig_obj[0] = args;
30372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30373 if (!SWIG_IsOK(res1)) {
30374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
30375 }
30376 arg1 = reinterpret_cast< wxWindow * >(argp1);
30377 {
30378 PyThreadState* __tstate = wxPyBeginAllowThreads();
30379 result = (int)((wxWindow const *)arg1)->GetId();
30380 wxPyEndAllowThreads(__tstate);
30381 if (PyErr_Occurred()) SWIG_fail;
30382 }
30383 resultobj = SWIG_From_int(static_cast< int >(result));
30384 return resultobj;
30385 fail:
30386 return NULL;
30387 }
30388
30389
30390 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30391 PyObject *resultobj = 0;
30392 int result;
30393
30394 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
30395 {
30396 PyThreadState* __tstate = wxPyBeginAllowThreads();
30397 result = (int)wxWindow::NewControlId();
30398 wxPyEndAllowThreads(__tstate);
30399 if (PyErr_Occurred()) SWIG_fail;
30400 }
30401 resultobj = SWIG_From_int(static_cast< int >(result));
30402 return resultobj;
30403 fail:
30404 return NULL;
30405 }
30406
30407
30408 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30409 PyObject *resultobj = 0;
30410 int arg1 ;
30411 int result;
30412 int val1 ;
30413 int ecode1 = 0 ;
30414 PyObject * obj0 = 0 ;
30415 char * kwnames[] = {
30416 (char *) "winid", NULL
30417 };
30418
30419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
30420 ecode1 = SWIG_AsVal_int(obj0, &val1);
30421 if (!SWIG_IsOK(ecode1)) {
30422 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
30423 }
30424 arg1 = static_cast< int >(val1);
30425 {
30426 PyThreadState* __tstate = wxPyBeginAllowThreads();
30427 result = (int)wxWindow::NextControlId(arg1);
30428 wxPyEndAllowThreads(__tstate);
30429 if (PyErr_Occurred()) SWIG_fail;
30430 }
30431 resultobj = SWIG_From_int(static_cast< int >(result));
30432 return resultobj;
30433 fail:
30434 return NULL;
30435 }
30436
30437
30438 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30439 PyObject *resultobj = 0;
30440 int arg1 ;
30441 int result;
30442 int val1 ;
30443 int ecode1 = 0 ;
30444 PyObject * obj0 = 0 ;
30445 char * kwnames[] = {
30446 (char *) "winid", NULL
30447 };
30448
30449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
30450 ecode1 = SWIG_AsVal_int(obj0, &val1);
30451 if (!SWIG_IsOK(ecode1)) {
30452 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
30453 }
30454 arg1 = static_cast< int >(val1);
30455 {
30456 PyThreadState* __tstate = wxPyBeginAllowThreads();
30457 result = (int)wxWindow::PrevControlId(arg1);
30458 wxPyEndAllowThreads(__tstate);
30459 if (PyErr_Occurred()) SWIG_fail;
30460 }
30461 resultobj = SWIG_From_int(static_cast< int >(result));
30462 return resultobj;
30463 fail:
30464 return NULL;
30465 }
30466
30467
30468 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30469 PyObject *resultobj = 0;
30470 wxWindow *arg1 = (wxWindow *) 0 ;
30471 wxSize *arg2 = 0 ;
30472 void *argp1 = 0 ;
30473 int res1 = 0 ;
30474 wxSize temp2 ;
30475 PyObject * obj0 = 0 ;
30476 PyObject * obj1 = 0 ;
30477 char * kwnames[] = {
30478 (char *) "self",(char *) "size", NULL
30479 };
30480
30481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
30482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30483 if (!SWIG_IsOK(res1)) {
30484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30485 }
30486 arg1 = reinterpret_cast< wxWindow * >(argp1);
30487 {
30488 arg2 = &temp2;
30489 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30490 }
30491 {
30492 PyThreadState* __tstate = wxPyBeginAllowThreads();
30493 (arg1)->SetSize((wxSize const &)*arg2);
30494 wxPyEndAllowThreads(__tstate);
30495 if (PyErr_Occurred()) SWIG_fail;
30496 }
30497 resultobj = SWIG_Py_Void();
30498 return resultobj;
30499 fail:
30500 return NULL;
30501 }
30502
30503
30504 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30505 PyObject *resultobj = 0;
30506 wxWindow *arg1 = (wxWindow *) 0 ;
30507 int arg2 ;
30508 int arg3 ;
30509 int arg4 ;
30510 int arg5 ;
30511 int arg6 = (int) wxSIZE_AUTO ;
30512 void *argp1 = 0 ;
30513 int res1 = 0 ;
30514 int val2 ;
30515 int ecode2 = 0 ;
30516 int val3 ;
30517 int ecode3 = 0 ;
30518 int val4 ;
30519 int ecode4 = 0 ;
30520 int val5 ;
30521 int ecode5 = 0 ;
30522 int val6 ;
30523 int ecode6 = 0 ;
30524 PyObject * obj0 = 0 ;
30525 PyObject * obj1 = 0 ;
30526 PyObject * obj2 = 0 ;
30527 PyObject * obj3 = 0 ;
30528 PyObject * obj4 = 0 ;
30529 PyObject * obj5 = 0 ;
30530 char * kwnames[] = {
30531 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
30532 };
30533
30534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30536 if (!SWIG_IsOK(res1)) {
30537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
30538 }
30539 arg1 = reinterpret_cast< wxWindow * >(argp1);
30540 ecode2 = SWIG_AsVal_int(obj1, &val2);
30541 if (!SWIG_IsOK(ecode2)) {
30542 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
30543 }
30544 arg2 = static_cast< int >(val2);
30545 ecode3 = SWIG_AsVal_int(obj2, &val3);
30546 if (!SWIG_IsOK(ecode3)) {
30547 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
30548 }
30549 arg3 = static_cast< int >(val3);
30550 ecode4 = SWIG_AsVal_int(obj3, &val4);
30551 if (!SWIG_IsOK(ecode4)) {
30552 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
30553 }
30554 arg4 = static_cast< int >(val4);
30555 ecode5 = SWIG_AsVal_int(obj4, &val5);
30556 if (!SWIG_IsOK(ecode5)) {
30557 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
30558 }
30559 arg5 = static_cast< int >(val5);
30560 if (obj5) {
30561 ecode6 = SWIG_AsVal_int(obj5, &val6);
30562 if (!SWIG_IsOK(ecode6)) {
30563 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
30564 }
30565 arg6 = static_cast< int >(val6);
30566 }
30567 {
30568 PyThreadState* __tstate = wxPyBeginAllowThreads();
30569 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
30570 wxPyEndAllowThreads(__tstate);
30571 if (PyErr_Occurred()) SWIG_fail;
30572 }
30573 resultobj = SWIG_Py_Void();
30574 return resultobj;
30575 fail:
30576 return NULL;
30577 }
30578
30579
30580 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30581 PyObject *resultobj = 0;
30582 wxWindow *arg1 = (wxWindow *) 0 ;
30583 wxRect *arg2 = 0 ;
30584 int arg3 = (int) wxSIZE_AUTO ;
30585 void *argp1 = 0 ;
30586 int res1 = 0 ;
30587 wxRect temp2 ;
30588 int val3 ;
30589 int ecode3 = 0 ;
30590 PyObject * obj0 = 0 ;
30591 PyObject * obj1 = 0 ;
30592 PyObject * obj2 = 0 ;
30593 char * kwnames[] = {
30594 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
30595 };
30596
30597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30599 if (!SWIG_IsOK(res1)) {
30600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30601 }
30602 arg1 = reinterpret_cast< wxWindow * >(argp1);
30603 {
30604 arg2 = &temp2;
30605 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30606 }
30607 if (obj2) {
30608 ecode3 = SWIG_AsVal_int(obj2, &val3);
30609 if (!SWIG_IsOK(ecode3)) {
30610 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
30611 }
30612 arg3 = static_cast< int >(val3);
30613 }
30614 {
30615 PyThreadState* __tstate = wxPyBeginAllowThreads();
30616 (arg1)->SetSize((wxRect const &)*arg2,arg3);
30617 wxPyEndAllowThreads(__tstate);
30618 if (PyErr_Occurred()) SWIG_fail;
30619 }
30620 resultobj = SWIG_Py_Void();
30621 return resultobj;
30622 fail:
30623 return NULL;
30624 }
30625
30626
30627 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30628 PyObject *resultobj = 0;
30629 wxWindow *arg1 = (wxWindow *) 0 ;
30630 int arg2 ;
30631 int arg3 ;
30632 void *argp1 = 0 ;
30633 int res1 = 0 ;
30634 int val2 ;
30635 int ecode2 = 0 ;
30636 int val3 ;
30637 int ecode3 = 0 ;
30638 PyObject * obj0 = 0 ;
30639 PyObject * obj1 = 0 ;
30640 PyObject * obj2 = 0 ;
30641 char * kwnames[] = {
30642 (char *) "self",(char *) "width",(char *) "height", NULL
30643 };
30644
30645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30647 if (!SWIG_IsOK(res1)) {
30648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30649 }
30650 arg1 = reinterpret_cast< wxWindow * >(argp1);
30651 ecode2 = SWIG_AsVal_int(obj1, &val2);
30652 if (!SWIG_IsOK(ecode2)) {
30653 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
30654 }
30655 arg2 = static_cast< int >(val2);
30656 ecode3 = SWIG_AsVal_int(obj2, &val3);
30657 if (!SWIG_IsOK(ecode3)) {
30658 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
30659 }
30660 arg3 = static_cast< int >(val3);
30661 {
30662 PyThreadState* __tstate = wxPyBeginAllowThreads();
30663 (arg1)->SetSize(arg2,arg3);
30664 wxPyEndAllowThreads(__tstate);
30665 if (PyErr_Occurred()) SWIG_fail;
30666 }
30667 resultobj = SWIG_Py_Void();
30668 return resultobj;
30669 fail:
30670 return NULL;
30671 }
30672
30673
30674 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30675 PyObject *resultobj = 0;
30676 wxWindow *arg1 = (wxWindow *) 0 ;
30677 wxPoint *arg2 = 0 ;
30678 int arg3 = (int) wxSIZE_USE_EXISTING ;
30679 void *argp1 = 0 ;
30680 int res1 = 0 ;
30681 wxPoint temp2 ;
30682 int val3 ;
30683 int ecode3 = 0 ;
30684 PyObject * obj0 = 0 ;
30685 PyObject * obj1 = 0 ;
30686 PyObject * obj2 = 0 ;
30687 char * kwnames[] = {
30688 (char *) "self",(char *) "pt",(char *) "flags", NULL
30689 };
30690
30691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30693 if (!SWIG_IsOK(res1)) {
30694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
30695 }
30696 arg1 = reinterpret_cast< wxWindow * >(argp1);
30697 {
30698 arg2 = &temp2;
30699 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30700 }
30701 if (obj2) {
30702 ecode3 = SWIG_AsVal_int(obj2, &val3);
30703 if (!SWIG_IsOK(ecode3)) {
30704 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
30705 }
30706 arg3 = static_cast< int >(val3);
30707 }
30708 {
30709 PyThreadState* __tstate = wxPyBeginAllowThreads();
30710 (arg1)->Move((wxPoint const &)*arg2,arg3);
30711 wxPyEndAllowThreads(__tstate);
30712 if (PyErr_Occurred()) SWIG_fail;
30713 }
30714 resultobj = SWIG_Py_Void();
30715 return resultobj;
30716 fail:
30717 return NULL;
30718 }
30719
30720
30721 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30722 PyObject *resultobj = 0;
30723 wxWindow *arg1 = (wxWindow *) 0 ;
30724 int arg2 ;
30725 int arg3 ;
30726 int arg4 = (int) wxSIZE_USE_EXISTING ;
30727 void *argp1 = 0 ;
30728 int res1 = 0 ;
30729 int val2 ;
30730 int ecode2 = 0 ;
30731 int val3 ;
30732 int ecode3 = 0 ;
30733 int val4 ;
30734 int ecode4 = 0 ;
30735 PyObject * obj0 = 0 ;
30736 PyObject * obj1 = 0 ;
30737 PyObject * obj2 = 0 ;
30738 PyObject * obj3 = 0 ;
30739 char * kwnames[] = {
30740 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
30741 };
30742
30743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30744 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30745 if (!SWIG_IsOK(res1)) {
30746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
30747 }
30748 arg1 = reinterpret_cast< wxWindow * >(argp1);
30749 ecode2 = SWIG_AsVal_int(obj1, &val2);
30750 if (!SWIG_IsOK(ecode2)) {
30751 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
30752 }
30753 arg2 = static_cast< int >(val2);
30754 ecode3 = SWIG_AsVal_int(obj2, &val3);
30755 if (!SWIG_IsOK(ecode3)) {
30756 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
30757 }
30758 arg3 = static_cast< int >(val3);
30759 if (obj3) {
30760 ecode4 = SWIG_AsVal_int(obj3, &val4);
30761 if (!SWIG_IsOK(ecode4)) {
30762 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
30763 }
30764 arg4 = static_cast< int >(val4);
30765 }
30766 {
30767 PyThreadState* __tstate = wxPyBeginAllowThreads();
30768 (arg1)->Move(arg2,arg3,arg4);
30769 wxPyEndAllowThreads(__tstate);
30770 if (PyErr_Occurred()) SWIG_fail;
30771 }
30772 resultobj = SWIG_Py_Void();
30773 return resultobj;
30774 fail:
30775 return NULL;
30776 }
30777
30778
30779 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30780 PyObject *resultobj = 0;
30781 wxWindow *arg1 = (wxWindow *) 0 ;
30782 wxSize const &arg2_defvalue = wxDefaultSize ;
30783 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
30784 void *argp1 = 0 ;
30785 int res1 = 0 ;
30786 wxSize temp2 ;
30787 PyObject * obj0 = 0 ;
30788 PyObject * obj1 = 0 ;
30789 char * kwnames[] = {
30790 (char *) "self",(char *) "size", NULL
30791 };
30792
30793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
30794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30795 if (!SWIG_IsOK(res1)) {
30796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30797 }
30798 arg1 = reinterpret_cast< wxWindow * >(argp1);
30799 if (obj1) {
30800 {
30801 arg2 = &temp2;
30802 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30803 }
30804 }
30805 {
30806 PyThreadState* __tstate = wxPyBeginAllowThreads();
30807 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
30808 wxPyEndAllowThreads(__tstate);
30809 if (PyErr_Occurred()) SWIG_fail;
30810 }
30811 resultobj = SWIG_Py_Void();
30812 return resultobj;
30813 fail:
30814 return NULL;
30815 }
30816
30817
30818 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30819 PyObject *resultobj = 0;
30820 wxWindow *arg1 = (wxWindow *) 0 ;
30821 void *argp1 = 0 ;
30822 int res1 = 0 ;
30823 PyObject *swig_obj[1] ;
30824
30825 if (!args) SWIG_fail;
30826 swig_obj[0] = args;
30827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30828 if (!SWIG_IsOK(res1)) {
30829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
30830 }
30831 arg1 = reinterpret_cast< wxWindow * >(argp1);
30832 {
30833 PyThreadState* __tstate = wxPyBeginAllowThreads();
30834 (arg1)->Raise();
30835 wxPyEndAllowThreads(__tstate);
30836 if (PyErr_Occurred()) SWIG_fail;
30837 }
30838 resultobj = SWIG_Py_Void();
30839 return resultobj;
30840 fail:
30841 return NULL;
30842 }
30843
30844
30845 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30846 PyObject *resultobj = 0;
30847 wxWindow *arg1 = (wxWindow *) 0 ;
30848 void *argp1 = 0 ;
30849 int res1 = 0 ;
30850 PyObject *swig_obj[1] ;
30851
30852 if (!args) SWIG_fail;
30853 swig_obj[0] = args;
30854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30855 if (!SWIG_IsOK(res1)) {
30856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
30857 }
30858 arg1 = reinterpret_cast< wxWindow * >(argp1);
30859 {
30860 PyThreadState* __tstate = wxPyBeginAllowThreads();
30861 (arg1)->Lower();
30862 wxPyEndAllowThreads(__tstate);
30863 if (PyErr_Occurred()) SWIG_fail;
30864 }
30865 resultobj = SWIG_Py_Void();
30866 return resultobj;
30867 fail:
30868 return NULL;
30869 }
30870
30871
30872 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30873 PyObject *resultobj = 0;
30874 wxWindow *arg1 = (wxWindow *) 0 ;
30875 wxSize *arg2 = 0 ;
30876 void *argp1 = 0 ;
30877 int res1 = 0 ;
30878 wxSize temp2 ;
30879 PyObject * obj0 = 0 ;
30880 PyObject * obj1 = 0 ;
30881 char * kwnames[] = {
30882 (char *) "self",(char *) "size", NULL
30883 };
30884
30885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
30886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30887 if (!SWIG_IsOK(res1)) {
30888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30889 }
30890 arg1 = reinterpret_cast< wxWindow * >(argp1);
30891 {
30892 arg2 = &temp2;
30893 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30894 }
30895 {
30896 PyThreadState* __tstate = wxPyBeginAllowThreads();
30897 (arg1)->SetClientSize((wxSize const &)*arg2);
30898 wxPyEndAllowThreads(__tstate);
30899 if (PyErr_Occurred()) SWIG_fail;
30900 }
30901 resultobj = SWIG_Py_Void();
30902 return resultobj;
30903 fail:
30904 return NULL;
30905 }
30906
30907
30908 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30909 PyObject *resultobj = 0;
30910 wxWindow *arg1 = (wxWindow *) 0 ;
30911 int arg2 ;
30912 int arg3 ;
30913 void *argp1 = 0 ;
30914 int res1 = 0 ;
30915 int val2 ;
30916 int ecode2 = 0 ;
30917 int val3 ;
30918 int ecode3 = 0 ;
30919 PyObject * obj0 = 0 ;
30920 PyObject * obj1 = 0 ;
30921 PyObject * obj2 = 0 ;
30922 char * kwnames[] = {
30923 (char *) "self",(char *) "width",(char *) "height", NULL
30924 };
30925
30926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30928 if (!SWIG_IsOK(res1)) {
30929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30930 }
30931 arg1 = reinterpret_cast< wxWindow * >(argp1);
30932 ecode2 = SWIG_AsVal_int(obj1, &val2);
30933 if (!SWIG_IsOK(ecode2)) {
30934 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
30935 }
30936 arg2 = static_cast< int >(val2);
30937 ecode3 = SWIG_AsVal_int(obj2, &val3);
30938 if (!SWIG_IsOK(ecode3)) {
30939 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
30940 }
30941 arg3 = static_cast< int >(val3);
30942 {
30943 PyThreadState* __tstate = wxPyBeginAllowThreads();
30944 (arg1)->SetClientSize(arg2,arg3);
30945 wxPyEndAllowThreads(__tstate);
30946 if (PyErr_Occurred()) SWIG_fail;
30947 }
30948 resultobj = SWIG_Py_Void();
30949 return resultobj;
30950 fail:
30951 return NULL;
30952 }
30953
30954
30955 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30956 PyObject *resultobj = 0;
30957 wxWindow *arg1 = (wxWindow *) 0 ;
30958 wxRect *arg2 = 0 ;
30959 void *argp1 = 0 ;
30960 int res1 = 0 ;
30961 wxRect temp2 ;
30962 PyObject * obj0 = 0 ;
30963 PyObject * obj1 = 0 ;
30964 char * kwnames[] = {
30965 (char *) "self",(char *) "rect", NULL
30966 };
30967
30968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
30969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30970 if (!SWIG_IsOK(res1)) {
30971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30972 }
30973 arg1 = reinterpret_cast< wxWindow * >(argp1);
30974 {
30975 arg2 = &temp2;
30976 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30977 }
30978 {
30979 PyThreadState* __tstate = wxPyBeginAllowThreads();
30980 (arg1)->SetClientSize((wxRect const &)*arg2);
30981 wxPyEndAllowThreads(__tstate);
30982 if (PyErr_Occurred()) SWIG_fail;
30983 }
30984 resultobj = SWIG_Py_Void();
30985 return resultobj;
30986 fail:
30987 return NULL;
30988 }
30989
30990
30991 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30992 PyObject *resultobj = 0;
30993 wxWindow *arg1 = (wxWindow *) 0 ;
30994 wxPoint result;
30995 void *argp1 = 0 ;
30996 int res1 = 0 ;
30997 PyObject *swig_obj[1] ;
30998
30999 if (!args) SWIG_fail;
31000 swig_obj[0] = args;
31001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31002 if (!SWIG_IsOK(res1)) {
31003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
31004 }
31005 arg1 = reinterpret_cast< wxWindow * >(argp1);
31006 {
31007 PyThreadState* __tstate = wxPyBeginAllowThreads();
31008 result = ((wxWindow const *)arg1)->GetPosition();
31009 wxPyEndAllowThreads(__tstate);
31010 if (PyErr_Occurred()) SWIG_fail;
31011 }
31012 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31013 return resultobj;
31014 fail:
31015 return NULL;
31016 }
31017
31018
31019 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31020 PyObject *resultobj = 0;
31021 wxWindow *arg1 = (wxWindow *) 0 ;
31022 int *arg2 = (int *) 0 ;
31023 int *arg3 = (int *) 0 ;
31024 void *argp1 = 0 ;
31025 int res1 = 0 ;
31026 int temp2 ;
31027 int res2 = SWIG_TMPOBJ ;
31028 int temp3 ;
31029 int res3 = SWIG_TMPOBJ ;
31030 PyObject *swig_obj[1] ;
31031
31032 arg2 = &temp2;
31033 arg3 = &temp3;
31034 if (!args) SWIG_fail;
31035 swig_obj[0] = args;
31036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31037 if (!SWIG_IsOK(res1)) {
31038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31039 }
31040 arg1 = reinterpret_cast< wxWindow * >(argp1);
31041 {
31042 PyThreadState* __tstate = wxPyBeginAllowThreads();
31043 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
31044 wxPyEndAllowThreads(__tstate);
31045 if (PyErr_Occurred()) SWIG_fail;
31046 }
31047 resultobj = SWIG_Py_Void();
31048 if (SWIG_IsTmpObj(res2)) {
31049 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31050 } else {
31051 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31052 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31053 }
31054 if (SWIG_IsTmpObj(res3)) {
31055 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31056 } else {
31057 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31058 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31059 }
31060 return resultobj;
31061 fail:
31062 return NULL;
31063 }
31064
31065
31066 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31067 PyObject *resultobj = 0;
31068 wxWindow *arg1 = (wxWindow *) 0 ;
31069 wxPoint result;
31070 void *argp1 = 0 ;
31071 int res1 = 0 ;
31072 PyObject *swig_obj[1] ;
31073
31074 if (!args) SWIG_fail;
31075 swig_obj[0] = args;
31076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31077 if (!SWIG_IsOK(res1)) {
31078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
31079 }
31080 arg1 = reinterpret_cast< wxWindow * >(argp1);
31081 {
31082 PyThreadState* __tstate = wxPyBeginAllowThreads();
31083 result = ((wxWindow const *)arg1)->GetScreenPosition();
31084 wxPyEndAllowThreads(__tstate);
31085 if (PyErr_Occurred()) SWIG_fail;
31086 }
31087 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31088 return resultobj;
31089 fail:
31090 return NULL;
31091 }
31092
31093
31094 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31095 PyObject *resultobj = 0;
31096 wxWindow *arg1 = (wxWindow *) 0 ;
31097 int *arg2 = (int *) 0 ;
31098 int *arg3 = (int *) 0 ;
31099 void *argp1 = 0 ;
31100 int res1 = 0 ;
31101 int temp2 ;
31102 int res2 = SWIG_TMPOBJ ;
31103 int temp3 ;
31104 int res3 = SWIG_TMPOBJ ;
31105 PyObject *swig_obj[1] ;
31106
31107 arg2 = &temp2;
31108 arg3 = &temp3;
31109 if (!args) SWIG_fail;
31110 swig_obj[0] = args;
31111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31112 if (!SWIG_IsOK(res1)) {
31113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31114 }
31115 arg1 = reinterpret_cast< wxWindow * >(argp1);
31116 {
31117 PyThreadState* __tstate = wxPyBeginAllowThreads();
31118 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
31119 wxPyEndAllowThreads(__tstate);
31120 if (PyErr_Occurred()) SWIG_fail;
31121 }
31122 resultobj = SWIG_Py_Void();
31123 if (SWIG_IsTmpObj(res2)) {
31124 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31125 } else {
31126 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31127 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31128 }
31129 if (SWIG_IsTmpObj(res3)) {
31130 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31131 } else {
31132 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31133 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31134 }
31135 return resultobj;
31136 fail:
31137 return NULL;
31138 }
31139
31140
31141 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31142 PyObject *resultobj = 0;
31143 wxWindow *arg1 = (wxWindow *) 0 ;
31144 wxRect result;
31145 void *argp1 = 0 ;
31146 int res1 = 0 ;
31147 PyObject *swig_obj[1] ;
31148
31149 if (!args) SWIG_fail;
31150 swig_obj[0] = args;
31151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31152 if (!SWIG_IsOK(res1)) {
31153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31154 }
31155 arg1 = reinterpret_cast< wxWindow * >(argp1);
31156 {
31157 PyThreadState* __tstate = wxPyBeginAllowThreads();
31158 result = ((wxWindow const *)arg1)->GetScreenRect();
31159 wxPyEndAllowThreads(__tstate);
31160 if (PyErr_Occurred()) SWIG_fail;
31161 }
31162 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31163 return resultobj;
31164 fail:
31165 return NULL;
31166 }
31167
31168
31169 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31170 PyObject *resultobj = 0;
31171 wxWindow *arg1 = (wxWindow *) 0 ;
31172 wxSize result;
31173 void *argp1 = 0 ;
31174 int res1 = 0 ;
31175 PyObject *swig_obj[1] ;
31176
31177 if (!args) SWIG_fail;
31178 swig_obj[0] = args;
31179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31180 if (!SWIG_IsOK(res1)) {
31181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31182 }
31183 arg1 = reinterpret_cast< wxWindow * >(argp1);
31184 {
31185 PyThreadState* __tstate = wxPyBeginAllowThreads();
31186 result = ((wxWindow const *)arg1)->GetSize();
31187 wxPyEndAllowThreads(__tstate);
31188 if (PyErr_Occurred()) SWIG_fail;
31189 }
31190 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31191 return resultobj;
31192 fail:
31193 return NULL;
31194 }
31195
31196
31197 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31198 PyObject *resultobj = 0;
31199 wxWindow *arg1 = (wxWindow *) 0 ;
31200 int *arg2 = (int *) 0 ;
31201 int *arg3 = (int *) 0 ;
31202 void *argp1 = 0 ;
31203 int res1 = 0 ;
31204 int temp2 ;
31205 int res2 = SWIG_TMPOBJ ;
31206 int temp3 ;
31207 int res3 = SWIG_TMPOBJ ;
31208 PyObject *swig_obj[1] ;
31209
31210 arg2 = &temp2;
31211 arg3 = &temp3;
31212 if (!args) SWIG_fail;
31213 swig_obj[0] = args;
31214 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31215 if (!SWIG_IsOK(res1)) {
31216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31217 }
31218 arg1 = reinterpret_cast< wxWindow * >(argp1);
31219 {
31220 PyThreadState* __tstate = wxPyBeginAllowThreads();
31221 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
31222 wxPyEndAllowThreads(__tstate);
31223 if (PyErr_Occurred()) SWIG_fail;
31224 }
31225 resultobj = SWIG_Py_Void();
31226 if (SWIG_IsTmpObj(res2)) {
31227 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31228 } else {
31229 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31230 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31231 }
31232 if (SWIG_IsTmpObj(res3)) {
31233 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31234 } else {
31235 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31236 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31237 }
31238 return resultobj;
31239 fail:
31240 return NULL;
31241 }
31242
31243
31244 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31245 PyObject *resultobj = 0;
31246 wxWindow *arg1 = (wxWindow *) 0 ;
31247 wxRect result;
31248 void *argp1 = 0 ;
31249 int res1 = 0 ;
31250 PyObject *swig_obj[1] ;
31251
31252 if (!args) SWIG_fail;
31253 swig_obj[0] = args;
31254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31255 if (!SWIG_IsOK(res1)) {
31256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31257 }
31258 arg1 = reinterpret_cast< wxWindow * >(argp1);
31259 {
31260 PyThreadState* __tstate = wxPyBeginAllowThreads();
31261 result = ((wxWindow const *)arg1)->GetRect();
31262 wxPyEndAllowThreads(__tstate);
31263 if (PyErr_Occurred()) SWIG_fail;
31264 }
31265 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31266 return resultobj;
31267 fail:
31268 return NULL;
31269 }
31270
31271
31272 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31273 PyObject *resultobj = 0;
31274 wxWindow *arg1 = (wxWindow *) 0 ;
31275 wxSize result;
31276 void *argp1 = 0 ;
31277 int res1 = 0 ;
31278 PyObject *swig_obj[1] ;
31279
31280 if (!args) SWIG_fail;
31281 swig_obj[0] = args;
31282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31283 if (!SWIG_IsOK(res1)) {
31284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31285 }
31286 arg1 = reinterpret_cast< wxWindow * >(argp1);
31287 {
31288 PyThreadState* __tstate = wxPyBeginAllowThreads();
31289 result = ((wxWindow const *)arg1)->GetClientSize();
31290 wxPyEndAllowThreads(__tstate);
31291 if (PyErr_Occurred()) SWIG_fail;
31292 }
31293 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31294 return resultobj;
31295 fail:
31296 return NULL;
31297 }
31298
31299
31300 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31301 PyObject *resultobj = 0;
31302 wxWindow *arg1 = (wxWindow *) 0 ;
31303 int *arg2 = (int *) 0 ;
31304 int *arg3 = (int *) 0 ;
31305 void *argp1 = 0 ;
31306 int res1 = 0 ;
31307 int temp2 ;
31308 int res2 = SWIG_TMPOBJ ;
31309 int temp3 ;
31310 int res3 = SWIG_TMPOBJ ;
31311 PyObject *swig_obj[1] ;
31312
31313 arg2 = &temp2;
31314 arg3 = &temp3;
31315 if (!args) SWIG_fail;
31316 swig_obj[0] = args;
31317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31318 if (!SWIG_IsOK(res1)) {
31319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31320 }
31321 arg1 = reinterpret_cast< wxWindow * >(argp1);
31322 {
31323 PyThreadState* __tstate = wxPyBeginAllowThreads();
31324 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
31325 wxPyEndAllowThreads(__tstate);
31326 if (PyErr_Occurred()) SWIG_fail;
31327 }
31328 resultobj = SWIG_Py_Void();
31329 if (SWIG_IsTmpObj(res2)) {
31330 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31331 } else {
31332 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31333 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31334 }
31335 if (SWIG_IsTmpObj(res3)) {
31336 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31337 } else {
31338 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31339 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31340 }
31341 return resultobj;
31342 fail:
31343 return NULL;
31344 }
31345
31346
31347 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31348 PyObject *resultobj = 0;
31349 wxWindow *arg1 = (wxWindow *) 0 ;
31350 wxPoint result;
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_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
31360 }
31361 arg1 = reinterpret_cast< wxWindow * >(argp1);
31362 {
31363 PyThreadState* __tstate = wxPyBeginAllowThreads();
31364 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
31365 wxPyEndAllowThreads(__tstate);
31366 if (PyErr_Occurred()) SWIG_fail;
31367 }
31368 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31369 return resultobj;
31370 fail:
31371 return NULL;
31372 }
31373
31374
31375 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31376 PyObject *resultobj = 0;
31377 wxWindow *arg1 = (wxWindow *) 0 ;
31378 wxRect result;
31379 void *argp1 = 0 ;
31380 int res1 = 0 ;
31381 PyObject *swig_obj[1] ;
31382
31383 if (!args) SWIG_fail;
31384 swig_obj[0] = args;
31385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31386 if (!SWIG_IsOK(res1)) {
31387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31388 }
31389 arg1 = reinterpret_cast< wxWindow * >(argp1);
31390 {
31391 PyThreadState* __tstate = wxPyBeginAllowThreads();
31392 result = ((wxWindow const *)arg1)->GetClientRect();
31393 wxPyEndAllowThreads(__tstate);
31394 if (PyErr_Occurred()) SWIG_fail;
31395 }
31396 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31397 return resultobj;
31398 fail:
31399 return NULL;
31400 }
31401
31402
31403 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31404 PyObject *resultobj = 0;
31405 wxWindow *arg1 = (wxWindow *) 0 ;
31406 wxSize result;
31407 void *argp1 = 0 ;
31408 int res1 = 0 ;
31409 PyObject *swig_obj[1] ;
31410
31411 if (!args) SWIG_fail;
31412 swig_obj[0] = args;
31413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31414 if (!SWIG_IsOK(res1)) {
31415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31416 }
31417 arg1 = reinterpret_cast< wxWindow * >(argp1);
31418 {
31419 PyThreadState* __tstate = wxPyBeginAllowThreads();
31420 result = ((wxWindow const *)arg1)->GetBestSize();
31421 wxPyEndAllowThreads(__tstate);
31422 if (PyErr_Occurred()) SWIG_fail;
31423 }
31424 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31425 return resultobj;
31426 fail:
31427 return NULL;
31428 }
31429
31430
31431 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31432 PyObject *resultobj = 0;
31433 wxWindow *arg1 = (wxWindow *) 0 ;
31434 int *arg2 = (int *) 0 ;
31435 int *arg3 = (int *) 0 ;
31436 void *argp1 = 0 ;
31437 int res1 = 0 ;
31438 int temp2 ;
31439 int res2 = SWIG_TMPOBJ ;
31440 int temp3 ;
31441 int res3 = SWIG_TMPOBJ ;
31442 PyObject *swig_obj[1] ;
31443
31444 arg2 = &temp2;
31445 arg3 = &temp3;
31446 if (!args) SWIG_fail;
31447 swig_obj[0] = args;
31448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31449 if (!SWIG_IsOK(res1)) {
31450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31451 }
31452 arg1 = reinterpret_cast< wxWindow * >(argp1);
31453 {
31454 PyThreadState* __tstate = wxPyBeginAllowThreads();
31455 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
31456 wxPyEndAllowThreads(__tstate);
31457 if (PyErr_Occurred()) SWIG_fail;
31458 }
31459 resultobj = SWIG_Py_Void();
31460 if (SWIG_IsTmpObj(res2)) {
31461 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31462 } else {
31463 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31464 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31465 }
31466 if (SWIG_IsTmpObj(res3)) {
31467 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31468 } else {
31469 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31470 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31471 }
31472 return resultobj;
31473 fail:
31474 return NULL;
31475 }
31476
31477
31478 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31479 PyObject *resultobj = 0;
31480 wxWindow *arg1 = (wxWindow *) 0 ;
31481 void *argp1 = 0 ;
31482 int res1 = 0 ;
31483 PyObject *swig_obj[1] ;
31484
31485 if (!args) SWIG_fail;
31486 swig_obj[0] = args;
31487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31488 if (!SWIG_IsOK(res1)) {
31489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31490 }
31491 arg1 = reinterpret_cast< wxWindow * >(argp1);
31492 {
31493 PyThreadState* __tstate = wxPyBeginAllowThreads();
31494 (arg1)->InvalidateBestSize();
31495 wxPyEndAllowThreads(__tstate);
31496 if (PyErr_Occurred()) SWIG_fail;
31497 }
31498 resultobj = SWIG_Py_Void();
31499 return resultobj;
31500 fail:
31501 return NULL;
31502 }
31503
31504
31505 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31506 PyObject *resultobj = 0;
31507 wxWindow *arg1 = (wxWindow *) 0 ;
31508 wxSize *arg2 = 0 ;
31509 void *argp1 = 0 ;
31510 int res1 = 0 ;
31511 wxSize temp2 ;
31512 PyObject * obj0 = 0 ;
31513 PyObject * obj1 = 0 ;
31514 char * kwnames[] = {
31515 (char *) "self",(char *) "size", NULL
31516 };
31517
31518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
31519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31520 if (!SWIG_IsOK(res1)) {
31521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31522 }
31523 arg1 = reinterpret_cast< wxWindow * >(argp1);
31524 {
31525 arg2 = &temp2;
31526 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31527 }
31528 {
31529 PyThreadState* __tstate = wxPyBeginAllowThreads();
31530 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
31531 wxPyEndAllowThreads(__tstate);
31532 if (PyErr_Occurred()) SWIG_fail;
31533 }
31534 resultobj = SWIG_Py_Void();
31535 return resultobj;
31536 fail:
31537 return NULL;
31538 }
31539
31540
31541 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31542 PyObject *resultobj = 0;
31543 wxWindow *arg1 = (wxWindow *) 0 ;
31544 wxSize result;
31545 void *argp1 = 0 ;
31546 int res1 = 0 ;
31547 PyObject *swig_obj[1] ;
31548
31549 if (!args) SWIG_fail;
31550 swig_obj[0] = args;
31551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31552 if (!SWIG_IsOK(res1)) {
31553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31554 }
31555 arg1 = reinterpret_cast< wxWindow * >(argp1);
31556 {
31557 PyThreadState* __tstate = wxPyBeginAllowThreads();
31558 result = ((wxWindow const *)arg1)->GetBestFittingSize();
31559 wxPyEndAllowThreads(__tstate);
31560 if (PyErr_Occurred()) SWIG_fail;
31561 }
31562 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31563 return resultobj;
31564 fail:
31565 return NULL;
31566 }
31567
31568
31569 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31570 PyObject *resultobj = 0;
31571 wxWindow *arg1 = (wxWindow *) 0 ;
31572 wxSize 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_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31582 }
31583 arg1 = reinterpret_cast< wxWindow * >(argp1);
31584 {
31585 PyThreadState* __tstate = wxPyBeginAllowThreads();
31586 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
31587 wxPyEndAllowThreads(__tstate);
31588 if (PyErr_Occurred()) SWIG_fail;
31589 }
31590 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31591 return resultobj;
31592 fail:
31593 return NULL;
31594 }
31595
31596
31597 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31598 PyObject *resultobj = 0;
31599 wxWindow *arg1 = (wxWindow *) 0 ;
31600 int arg2 = (int) wxBOTH ;
31601 void *argp1 = 0 ;
31602 int res1 = 0 ;
31603 int val2 ;
31604 int ecode2 = 0 ;
31605 PyObject * obj0 = 0 ;
31606 PyObject * obj1 = 0 ;
31607 char * kwnames[] = {
31608 (char *) "self",(char *) "direction", NULL
31609 };
31610
31611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
31612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31613 if (!SWIG_IsOK(res1)) {
31614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
31615 }
31616 arg1 = reinterpret_cast< wxWindow * >(argp1);
31617 if (obj1) {
31618 ecode2 = SWIG_AsVal_int(obj1, &val2);
31619 if (!SWIG_IsOK(ecode2)) {
31620 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
31621 }
31622 arg2 = static_cast< int >(val2);
31623 }
31624 {
31625 PyThreadState* __tstate = wxPyBeginAllowThreads();
31626 (arg1)->Center(arg2);
31627 wxPyEndAllowThreads(__tstate);
31628 if (PyErr_Occurred()) SWIG_fail;
31629 }
31630 resultobj = SWIG_Py_Void();
31631 return resultobj;
31632 fail:
31633 return NULL;
31634 }
31635
31636
31637 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31638 PyObject *resultobj = 0;
31639 wxWindow *arg1 = (wxWindow *) 0 ;
31640 int arg2 = (int) wxBOTH ;
31641 void *argp1 = 0 ;
31642 int res1 = 0 ;
31643 int val2 ;
31644 int ecode2 = 0 ;
31645 PyObject * obj0 = 0 ;
31646 PyObject * obj1 = 0 ;
31647 char * kwnames[] = {
31648 (char *) "self",(char *) "dir", NULL
31649 };
31650
31651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
31652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31653 if (!SWIG_IsOK(res1)) {
31654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
31655 }
31656 arg1 = reinterpret_cast< wxWindow * >(argp1);
31657 if (obj1) {
31658 ecode2 = SWIG_AsVal_int(obj1, &val2);
31659 if (!SWIG_IsOK(ecode2)) {
31660 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
31661 }
31662 arg2 = static_cast< int >(val2);
31663 }
31664 {
31665 PyThreadState* __tstate = wxPyBeginAllowThreads();
31666 (arg1)->CenterOnParent(arg2);
31667 wxPyEndAllowThreads(__tstate);
31668 if (PyErr_Occurred()) SWIG_fail;
31669 }
31670 resultobj = SWIG_Py_Void();
31671 return resultobj;
31672 fail:
31673 return NULL;
31674 }
31675
31676
31677 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31678 PyObject *resultobj = 0;
31679 wxWindow *arg1 = (wxWindow *) 0 ;
31680 void *argp1 = 0 ;
31681 int res1 = 0 ;
31682 PyObject *swig_obj[1] ;
31683
31684 if (!args) SWIG_fail;
31685 swig_obj[0] = args;
31686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31687 if (!SWIG_IsOK(res1)) {
31688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
31689 }
31690 arg1 = reinterpret_cast< wxWindow * >(argp1);
31691 {
31692 PyThreadState* __tstate = wxPyBeginAllowThreads();
31693 (arg1)->Fit();
31694 wxPyEndAllowThreads(__tstate);
31695 if (PyErr_Occurred()) SWIG_fail;
31696 }
31697 resultobj = SWIG_Py_Void();
31698 return resultobj;
31699 fail:
31700 return NULL;
31701 }
31702
31703
31704 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31705 PyObject *resultobj = 0;
31706 wxWindow *arg1 = (wxWindow *) 0 ;
31707 void *argp1 = 0 ;
31708 int res1 = 0 ;
31709 PyObject *swig_obj[1] ;
31710
31711 if (!args) SWIG_fail;
31712 swig_obj[0] = args;
31713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31714 if (!SWIG_IsOK(res1)) {
31715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
31716 }
31717 arg1 = reinterpret_cast< wxWindow * >(argp1);
31718 {
31719 PyThreadState* __tstate = wxPyBeginAllowThreads();
31720 (arg1)->FitInside();
31721 wxPyEndAllowThreads(__tstate);
31722 if (PyErr_Occurred()) SWIG_fail;
31723 }
31724 resultobj = SWIG_Py_Void();
31725 return resultobj;
31726 fail:
31727 return NULL;
31728 }
31729
31730
31731 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31732 PyObject *resultobj = 0;
31733 wxWindow *arg1 = (wxWindow *) 0 ;
31734 int arg2 ;
31735 int arg3 ;
31736 int arg4 = (int) -1 ;
31737 int arg5 = (int) -1 ;
31738 int arg6 = (int) -1 ;
31739 int arg7 = (int) -1 ;
31740 void *argp1 = 0 ;
31741 int res1 = 0 ;
31742 int val2 ;
31743 int ecode2 = 0 ;
31744 int val3 ;
31745 int ecode3 = 0 ;
31746 int val4 ;
31747 int ecode4 = 0 ;
31748 int val5 ;
31749 int ecode5 = 0 ;
31750 int val6 ;
31751 int ecode6 = 0 ;
31752 int val7 ;
31753 int ecode7 = 0 ;
31754 PyObject * obj0 = 0 ;
31755 PyObject * obj1 = 0 ;
31756 PyObject * obj2 = 0 ;
31757 PyObject * obj3 = 0 ;
31758 PyObject * obj4 = 0 ;
31759 PyObject * obj5 = 0 ;
31760 PyObject * obj6 = 0 ;
31761 char * kwnames[] = {
31762 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
31763 };
31764
31765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
31766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31767 if (!SWIG_IsOK(res1)) {
31768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31769 }
31770 arg1 = reinterpret_cast< wxWindow * >(argp1);
31771 ecode2 = SWIG_AsVal_int(obj1, &val2);
31772 if (!SWIG_IsOK(ecode2)) {
31773 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
31774 }
31775 arg2 = static_cast< int >(val2);
31776 ecode3 = SWIG_AsVal_int(obj2, &val3);
31777 if (!SWIG_IsOK(ecode3)) {
31778 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
31779 }
31780 arg3 = static_cast< int >(val3);
31781 if (obj3) {
31782 ecode4 = SWIG_AsVal_int(obj3, &val4);
31783 if (!SWIG_IsOK(ecode4)) {
31784 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
31785 }
31786 arg4 = static_cast< int >(val4);
31787 }
31788 if (obj4) {
31789 ecode5 = SWIG_AsVal_int(obj4, &val5);
31790 if (!SWIG_IsOK(ecode5)) {
31791 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
31792 }
31793 arg5 = static_cast< int >(val5);
31794 }
31795 if (obj5) {
31796 ecode6 = SWIG_AsVal_int(obj5, &val6);
31797 if (!SWIG_IsOK(ecode6)) {
31798 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
31799 }
31800 arg6 = static_cast< int >(val6);
31801 }
31802 if (obj6) {
31803 ecode7 = SWIG_AsVal_int(obj6, &val7);
31804 if (!SWIG_IsOK(ecode7)) {
31805 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
31806 }
31807 arg7 = static_cast< int >(val7);
31808 }
31809 {
31810 PyThreadState* __tstate = wxPyBeginAllowThreads();
31811 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
31812 wxPyEndAllowThreads(__tstate);
31813 if (PyErr_Occurred()) SWIG_fail;
31814 }
31815 resultobj = SWIG_Py_Void();
31816 return resultobj;
31817 fail:
31818 return NULL;
31819 }
31820
31821
31822 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31823 PyObject *resultobj = 0;
31824 wxWindow *arg1 = (wxWindow *) 0 ;
31825 wxSize *arg2 = 0 ;
31826 wxSize const &arg3_defvalue = wxDefaultSize ;
31827 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31828 wxSize const &arg4_defvalue = wxDefaultSize ;
31829 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
31830 void *argp1 = 0 ;
31831 int res1 = 0 ;
31832 wxSize temp2 ;
31833 wxSize temp3 ;
31834 wxSize temp4 ;
31835 PyObject * obj0 = 0 ;
31836 PyObject * obj1 = 0 ;
31837 PyObject * obj2 = 0 ;
31838 PyObject * obj3 = 0 ;
31839 char * kwnames[] = {
31840 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
31841 };
31842
31843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31845 if (!SWIG_IsOK(res1)) {
31846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31847 }
31848 arg1 = reinterpret_cast< wxWindow * >(argp1);
31849 {
31850 arg2 = &temp2;
31851 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31852 }
31853 if (obj2) {
31854 {
31855 arg3 = &temp3;
31856 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31857 }
31858 }
31859 if (obj3) {
31860 {
31861 arg4 = &temp4;
31862 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
31863 }
31864 }
31865 {
31866 PyThreadState* __tstate = wxPyBeginAllowThreads();
31867 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
31868 wxPyEndAllowThreads(__tstate);
31869 if (PyErr_Occurred()) SWIG_fail;
31870 }
31871 resultobj = SWIG_Py_Void();
31872 return resultobj;
31873 fail:
31874 return NULL;
31875 }
31876
31877
31878 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31879 PyObject *resultobj = 0;
31880 wxWindow *arg1 = (wxWindow *) 0 ;
31881 int arg2 ;
31882 int arg3 ;
31883 int arg4 = (int) -1 ;
31884 int arg5 = (int) -1 ;
31885 void *argp1 = 0 ;
31886 int res1 = 0 ;
31887 int val2 ;
31888 int ecode2 = 0 ;
31889 int val3 ;
31890 int ecode3 = 0 ;
31891 int val4 ;
31892 int ecode4 = 0 ;
31893 int val5 ;
31894 int ecode5 = 0 ;
31895 PyObject * obj0 = 0 ;
31896 PyObject * obj1 = 0 ;
31897 PyObject * obj2 = 0 ;
31898 PyObject * obj3 = 0 ;
31899 PyObject * obj4 = 0 ;
31900 char * kwnames[] = {
31901 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
31902 };
31903
31904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31906 if (!SWIG_IsOK(res1)) {
31907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31908 }
31909 arg1 = reinterpret_cast< wxWindow * >(argp1);
31910 ecode2 = SWIG_AsVal_int(obj1, &val2);
31911 if (!SWIG_IsOK(ecode2)) {
31912 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
31913 }
31914 arg2 = static_cast< int >(val2);
31915 ecode3 = SWIG_AsVal_int(obj2, &val3);
31916 if (!SWIG_IsOK(ecode3)) {
31917 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
31918 }
31919 arg3 = static_cast< int >(val3);
31920 if (obj3) {
31921 ecode4 = SWIG_AsVal_int(obj3, &val4);
31922 if (!SWIG_IsOK(ecode4)) {
31923 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
31924 }
31925 arg4 = static_cast< int >(val4);
31926 }
31927 if (obj4) {
31928 ecode5 = SWIG_AsVal_int(obj4, &val5);
31929 if (!SWIG_IsOK(ecode5)) {
31930 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
31931 }
31932 arg5 = static_cast< int >(val5);
31933 }
31934 {
31935 PyThreadState* __tstate = wxPyBeginAllowThreads();
31936 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
31937 wxPyEndAllowThreads(__tstate);
31938 if (PyErr_Occurred()) SWIG_fail;
31939 }
31940 resultobj = SWIG_Py_Void();
31941 return resultobj;
31942 fail:
31943 return NULL;
31944 }
31945
31946
31947 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31948 PyObject *resultobj = 0;
31949 wxWindow *arg1 = (wxWindow *) 0 ;
31950 wxSize *arg2 = 0 ;
31951 wxSize const &arg3_defvalue = wxDefaultSize ;
31952 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31953 void *argp1 = 0 ;
31954 int res1 = 0 ;
31955 wxSize temp2 ;
31956 wxSize temp3 ;
31957 PyObject * obj0 = 0 ;
31958 PyObject * obj1 = 0 ;
31959 PyObject * obj2 = 0 ;
31960 char * kwnames[] = {
31961 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
31962 };
31963
31964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31966 if (!SWIG_IsOK(res1)) {
31967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31968 }
31969 arg1 = reinterpret_cast< wxWindow * >(argp1);
31970 {
31971 arg2 = &temp2;
31972 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31973 }
31974 if (obj2) {
31975 {
31976 arg3 = &temp3;
31977 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31978 }
31979 }
31980 {
31981 PyThreadState* __tstate = wxPyBeginAllowThreads();
31982 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
31983 wxPyEndAllowThreads(__tstate);
31984 if (PyErr_Occurred()) SWIG_fail;
31985 }
31986 resultobj = SWIG_Py_Void();
31987 return resultobj;
31988 fail:
31989 return NULL;
31990 }
31991
31992
31993 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31994 PyObject *resultobj = 0;
31995 wxWindow *arg1 = (wxWindow *) 0 ;
31996 wxSize result;
31997 void *argp1 = 0 ;
31998 int res1 = 0 ;
31999 PyObject *swig_obj[1] ;
32000
32001 if (!args) SWIG_fail;
32002 swig_obj[0] = args;
32003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32004 if (!SWIG_IsOK(res1)) {
32005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32006 }
32007 arg1 = reinterpret_cast< wxWindow * >(argp1);
32008 {
32009 PyThreadState* __tstate = wxPyBeginAllowThreads();
32010 result = ((wxWindow const *)arg1)->GetMaxSize();
32011 wxPyEndAllowThreads(__tstate);
32012 if (PyErr_Occurred()) SWIG_fail;
32013 }
32014 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32015 return resultobj;
32016 fail:
32017 return NULL;
32018 }
32019
32020
32021 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32022 PyObject *resultobj = 0;
32023 wxWindow *arg1 = (wxWindow *) 0 ;
32024 wxSize result;
32025 void *argp1 = 0 ;
32026 int res1 = 0 ;
32027 PyObject *swig_obj[1] ;
32028
32029 if (!args) SWIG_fail;
32030 swig_obj[0] = args;
32031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32032 if (!SWIG_IsOK(res1)) {
32033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32034 }
32035 arg1 = reinterpret_cast< wxWindow * >(argp1);
32036 {
32037 PyThreadState* __tstate = wxPyBeginAllowThreads();
32038 result = ((wxWindow const *)arg1)->GetMinSize();
32039 wxPyEndAllowThreads(__tstate);
32040 if (PyErr_Occurred()) SWIG_fail;
32041 }
32042 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32043 return resultobj;
32044 fail:
32045 return NULL;
32046 }
32047
32048
32049 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32050 PyObject *resultobj = 0;
32051 wxWindow *arg1 = (wxWindow *) 0 ;
32052 wxSize *arg2 = 0 ;
32053 void *argp1 = 0 ;
32054 int res1 = 0 ;
32055 wxSize temp2 ;
32056 PyObject * obj0 = 0 ;
32057 PyObject * obj1 = 0 ;
32058 char * kwnames[] = {
32059 (char *) "self",(char *) "minSize", NULL
32060 };
32061
32062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
32063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32064 if (!SWIG_IsOK(res1)) {
32065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32066 }
32067 arg1 = reinterpret_cast< wxWindow * >(argp1);
32068 {
32069 arg2 = &temp2;
32070 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32071 }
32072 {
32073 PyThreadState* __tstate = wxPyBeginAllowThreads();
32074 (arg1)->SetMinSize((wxSize const &)*arg2);
32075 wxPyEndAllowThreads(__tstate);
32076 if (PyErr_Occurred()) SWIG_fail;
32077 }
32078 resultobj = SWIG_Py_Void();
32079 return resultobj;
32080 fail:
32081 return NULL;
32082 }
32083
32084
32085 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32086 PyObject *resultobj = 0;
32087 wxWindow *arg1 = (wxWindow *) 0 ;
32088 wxSize *arg2 = 0 ;
32089 void *argp1 = 0 ;
32090 int res1 = 0 ;
32091 wxSize temp2 ;
32092 PyObject * obj0 = 0 ;
32093 PyObject * obj1 = 0 ;
32094 char * kwnames[] = {
32095 (char *) "self",(char *) "maxSize", NULL
32096 };
32097
32098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
32099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32100 if (!SWIG_IsOK(res1)) {
32101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32102 }
32103 arg1 = reinterpret_cast< wxWindow * >(argp1);
32104 {
32105 arg2 = &temp2;
32106 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32107 }
32108 {
32109 PyThreadState* __tstate = wxPyBeginAllowThreads();
32110 (arg1)->SetMaxSize((wxSize const &)*arg2);
32111 wxPyEndAllowThreads(__tstate);
32112 if (PyErr_Occurred()) SWIG_fail;
32113 }
32114 resultobj = SWIG_Py_Void();
32115 return resultobj;
32116 fail:
32117 return NULL;
32118 }
32119
32120
32121 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32122 PyObject *resultobj = 0;
32123 wxWindow *arg1 = (wxWindow *) 0 ;
32124 int result;
32125 void *argp1 = 0 ;
32126 int res1 = 0 ;
32127 PyObject *swig_obj[1] ;
32128
32129 if (!args) SWIG_fail;
32130 swig_obj[0] = args;
32131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32132 if (!SWIG_IsOK(res1)) {
32133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
32134 }
32135 arg1 = reinterpret_cast< wxWindow * >(argp1);
32136 {
32137 PyThreadState* __tstate = wxPyBeginAllowThreads();
32138 result = (int)((wxWindow const *)arg1)->GetMinWidth();
32139 wxPyEndAllowThreads(__tstate);
32140 if (PyErr_Occurred()) SWIG_fail;
32141 }
32142 resultobj = SWIG_From_int(static_cast< int >(result));
32143 return resultobj;
32144 fail:
32145 return NULL;
32146 }
32147
32148
32149 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32150 PyObject *resultobj = 0;
32151 wxWindow *arg1 = (wxWindow *) 0 ;
32152 int result;
32153 void *argp1 = 0 ;
32154 int res1 = 0 ;
32155 PyObject *swig_obj[1] ;
32156
32157 if (!args) SWIG_fail;
32158 swig_obj[0] = args;
32159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32160 if (!SWIG_IsOK(res1)) {
32161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
32162 }
32163 arg1 = reinterpret_cast< wxWindow * >(argp1);
32164 {
32165 PyThreadState* __tstate = wxPyBeginAllowThreads();
32166 result = (int)((wxWindow const *)arg1)->GetMinHeight();
32167 wxPyEndAllowThreads(__tstate);
32168 if (PyErr_Occurred()) SWIG_fail;
32169 }
32170 resultobj = SWIG_From_int(static_cast< int >(result));
32171 return resultobj;
32172 fail:
32173 return NULL;
32174 }
32175
32176
32177 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32178 PyObject *resultobj = 0;
32179 wxWindow *arg1 = (wxWindow *) 0 ;
32180 int result;
32181 void *argp1 = 0 ;
32182 int res1 = 0 ;
32183 PyObject *swig_obj[1] ;
32184
32185 if (!args) SWIG_fail;
32186 swig_obj[0] = args;
32187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32188 if (!SWIG_IsOK(res1)) {
32189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
32190 }
32191 arg1 = reinterpret_cast< wxWindow * >(argp1);
32192 {
32193 PyThreadState* __tstate = wxPyBeginAllowThreads();
32194 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
32195 wxPyEndAllowThreads(__tstate);
32196 if (PyErr_Occurred()) SWIG_fail;
32197 }
32198 resultobj = SWIG_From_int(static_cast< int >(result));
32199 return resultobj;
32200 fail:
32201 return NULL;
32202 }
32203
32204
32205 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32206 PyObject *resultobj = 0;
32207 wxWindow *arg1 = (wxWindow *) 0 ;
32208 int result;
32209 void *argp1 = 0 ;
32210 int res1 = 0 ;
32211 PyObject *swig_obj[1] ;
32212
32213 if (!args) SWIG_fail;
32214 swig_obj[0] = args;
32215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32216 if (!SWIG_IsOK(res1)) {
32217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
32218 }
32219 arg1 = reinterpret_cast< wxWindow * >(argp1);
32220 {
32221 PyThreadState* __tstate = wxPyBeginAllowThreads();
32222 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
32223 wxPyEndAllowThreads(__tstate);
32224 if (PyErr_Occurred()) SWIG_fail;
32225 }
32226 resultobj = SWIG_From_int(static_cast< int >(result));
32227 return resultobj;
32228 fail:
32229 return NULL;
32230 }
32231
32232
32233 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32234 PyObject *resultobj = 0;
32235 wxWindow *arg1 = (wxWindow *) 0 ;
32236 wxSize *arg2 = 0 ;
32237 void *argp1 = 0 ;
32238 int res1 = 0 ;
32239 wxSize temp2 ;
32240 PyObject * obj0 = 0 ;
32241 PyObject * obj1 = 0 ;
32242 char * kwnames[] = {
32243 (char *) "self",(char *) "size", NULL
32244 };
32245
32246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
32247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32248 if (!SWIG_IsOK(res1)) {
32249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32250 }
32251 arg1 = reinterpret_cast< wxWindow * >(argp1);
32252 {
32253 arg2 = &temp2;
32254 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32255 }
32256 {
32257 PyThreadState* __tstate = wxPyBeginAllowThreads();
32258 (arg1)->SetVirtualSize((wxSize const &)*arg2);
32259 wxPyEndAllowThreads(__tstate);
32260 if (PyErr_Occurred()) SWIG_fail;
32261 }
32262 resultobj = SWIG_Py_Void();
32263 return resultobj;
32264 fail:
32265 return NULL;
32266 }
32267
32268
32269 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32270 PyObject *resultobj = 0;
32271 wxWindow *arg1 = (wxWindow *) 0 ;
32272 int arg2 ;
32273 int arg3 ;
32274 void *argp1 = 0 ;
32275 int res1 = 0 ;
32276 int val2 ;
32277 int ecode2 = 0 ;
32278 int val3 ;
32279 int ecode3 = 0 ;
32280 PyObject * obj0 = 0 ;
32281 PyObject * obj1 = 0 ;
32282 PyObject * obj2 = 0 ;
32283 char * kwnames[] = {
32284 (char *) "self",(char *) "w",(char *) "h", NULL
32285 };
32286
32287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32289 if (!SWIG_IsOK(res1)) {
32290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
32291 }
32292 arg1 = reinterpret_cast< wxWindow * >(argp1);
32293 ecode2 = SWIG_AsVal_int(obj1, &val2);
32294 if (!SWIG_IsOK(ecode2)) {
32295 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
32296 }
32297 arg2 = static_cast< int >(val2);
32298 ecode3 = SWIG_AsVal_int(obj2, &val3);
32299 if (!SWIG_IsOK(ecode3)) {
32300 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
32301 }
32302 arg3 = static_cast< int >(val3);
32303 {
32304 PyThreadState* __tstate = wxPyBeginAllowThreads();
32305 (arg1)->SetVirtualSize(arg2,arg3);
32306 wxPyEndAllowThreads(__tstate);
32307 if (PyErr_Occurred()) SWIG_fail;
32308 }
32309 resultobj = SWIG_Py_Void();
32310 return resultobj;
32311 fail:
32312 return NULL;
32313 }
32314
32315
32316 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32317 PyObject *resultobj = 0;
32318 wxWindow *arg1 = (wxWindow *) 0 ;
32319 wxSize result;
32320 void *argp1 = 0 ;
32321 int res1 = 0 ;
32322 PyObject *swig_obj[1] ;
32323
32324 if (!args) SWIG_fail;
32325 swig_obj[0] = args;
32326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32327 if (!SWIG_IsOK(res1)) {
32328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32329 }
32330 arg1 = reinterpret_cast< wxWindow * >(argp1);
32331 {
32332 PyThreadState* __tstate = wxPyBeginAllowThreads();
32333 result = ((wxWindow const *)arg1)->GetVirtualSize();
32334 wxPyEndAllowThreads(__tstate);
32335 if (PyErr_Occurred()) SWIG_fail;
32336 }
32337 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32338 return resultobj;
32339 fail:
32340 return NULL;
32341 }
32342
32343
32344 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32345 PyObject *resultobj = 0;
32346 wxWindow *arg1 = (wxWindow *) 0 ;
32347 int *arg2 = (int *) 0 ;
32348 int *arg3 = (int *) 0 ;
32349 void *argp1 = 0 ;
32350 int res1 = 0 ;
32351 int temp2 ;
32352 int res2 = SWIG_TMPOBJ ;
32353 int temp3 ;
32354 int res3 = SWIG_TMPOBJ ;
32355 PyObject *swig_obj[1] ;
32356
32357 arg2 = &temp2;
32358 arg3 = &temp3;
32359 if (!args) SWIG_fail;
32360 swig_obj[0] = args;
32361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32362 if (!SWIG_IsOK(res1)) {
32363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32364 }
32365 arg1 = reinterpret_cast< wxWindow * >(argp1);
32366 {
32367 PyThreadState* __tstate = wxPyBeginAllowThreads();
32368 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
32369 wxPyEndAllowThreads(__tstate);
32370 if (PyErr_Occurred()) SWIG_fail;
32371 }
32372 resultobj = SWIG_Py_Void();
32373 if (SWIG_IsTmpObj(res2)) {
32374 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32375 } else {
32376 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32377 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32378 }
32379 if (SWIG_IsTmpObj(res3)) {
32380 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32381 } else {
32382 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32383 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32384 }
32385 return resultobj;
32386 fail:
32387 return NULL;
32388 }
32389
32390
32391 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32392 PyObject *resultobj = 0;
32393 wxWindow *arg1 = (wxWindow *) 0 ;
32394 wxSize result;
32395 void *argp1 = 0 ;
32396 int res1 = 0 ;
32397 PyObject *swig_obj[1] ;
32398
32399 if (!args) SWIG_fail;
32400 swig_obj[0] = args;
32401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32402 if (!SWIG_IsOK(res1)) {
32403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32404 }
32405 arg1 = reinterpret_cast< wxWindow * >(argp1);
32406 {
32407 PyThreadState* __tstate = wxPyBeginAllowThreads();
32408 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
32409 wxPyEndAllowThreads(__tstate);
32410 if (PyErr_Occurred()) SWIG_fail;
32411 }
32412 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32413 return resultobj;
32414 fail:
32415 return NULL;
32416 }
32417
32418
32419 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32420 PyObject *resultobj = 0;
32421 wxWindow *arg1 = (wxWindow *) 0 ;
32422 bool arg2 = (bool) true ;
32423 bool result;
32424 void *argp1 = 0 ;
32425 int res1 = 0 ;
32426 bool val2 ;
32427 int ecode2 = 0 ;
32428 PyObject * obj0 = 0 ;
32429 PyObject * obj1 = 0 ;
32430 char * kwnames[] = {
32431 (char *) "self",(char *) "show", NULL
32432 };
32433
32434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
32435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32436 if (!SWIG_IsOK(res1)) {
32437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
32438 }
32439 arg1 = reinterpret_cast< wxWindow * >(argp1);
32440 if (obj1) {
32441 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32442 if (!SWIG_IsOK(ecode2)) {
32443 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
32444 }
32445 arg2 = static_cast< bool >(val2);
32446 }
32447 {
32448 PyThreadState* __tstate = wxPyBeginAllowThreads();
32449 result = (bool)(arg1)->Show(arg2);
32450 wxPyEndAllowThreads(__tstate);
32451 if (PyErr_Occurred()) SWIG_fail;
32452 }
32453 {
32454 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32455 }
32456 return resultobj;
32457 fail:
32458 return NULL;
32459 }
32460
32461
32462 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32463 PyObject *resultobj = 0;
32464 wxWindow *arg1 = (wxWindow *) 0 ;
32465 bool result;
32466 void *argp1 = 0 ;
32467 int res1 = 0 ;
32468 PyObject *swig_obj[1] ;
32469
32470 if (!args) SWIG_fail;
32471 swig_obj[0] = args;
32472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32473 if (!SWIG_IsOK(res1)) {
32474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
32475 }
32476 arg1 = reinterpret_cast< wxWindow * >(argp1);
32477 {
32478 PyThreadState* __tstate = wxPyBeginAllowThreads();
32479 result = (bool)(arg1)->Hide();
32480 wxPyEndAllowThreads(__tstate);
32481 if (PyErr_Occurred()) SWIG_fail;
32482 }
32483 {
32484 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32485 }
32486 return resultobj;
32487 fail:
32488 return NULL;
32489 }
32490
32491
32492 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32493 PyObject *resultobj = 0;
32494 wxWindow *arg1 = (wxWindow *) 0 ;
32495 bool arg2 = (bool) true ;
32496 bool result;
32497 void *argp1 = 0 ;
32498 int res1 = 0 ;
32499 bool val2 ;
32500 int ecode2 = 0 ;
32501 PyObject * obj0 = 0 ;
32502 PyObject * obj1 = 0 ;
32503 char * kwnames[] = {
32504 (char *) "self",(char *) "enable", NULL
32505 };
32506
32507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
32508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32509 if (!SWIG_IsOK(res1)) {
32510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
32511 }
32512 arg1 = reinterpret_cast< wxWindow * >(argp1);
32513 if (obj1) {
32514 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32515 if (!SWIG_IsOK(ecode2)) {
32516 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
32517 }
32518 arg2 = static_cast< bool >(val2);
32519 }
32520 {
32521 PyThreadState* __tstate = wxPyBeginAllowThreads();
32522 result = (bool)(arg1)->Enable(arg2);
32523 wxPyEndAllowThreads(__tstate);
32524 if (PyErr_Occurred()) SWIG_fail;
32525 }
32526 {
32527 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32528 }
32529 return resultobj;
32530 fail:
32531 return NULL;
32532 }
32533
32534
32535 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32536 PyObject *resultobj = 0;
32537 wxWindow *arg1 = (wxWindow *) 0 ;
32538 bool result;
32539 void *argp1 = 0 ;
32540 int res1 = 0 ;
32541 PyObject *swig_obj[1] ;
32542
32543 if (!args) SWIG_fail;
32544 swig_obj[0] = args;
32545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32546 if (!SWIG_IsOK(res1)) {
32547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
32548 }
32549 arg1 = reinterpret_cast< wxWindow * >(argp1);
32550 {
32551 PyThreadState* __tstate = wxPyBeginAllowThreads();
32552 result = (bool)(arg1)->Disable();
32553 wxPyEndAllowThreads(__tstate);
32554 if (PyErr_Occurred()) SWIG_fail;
32555 }
32556 {
32557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32558 }
32559 return resultobj;
32560 fail:
32561 return NULL;
32562 }
32563
32564
32565 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32566 PyObject *resultobj = 0;
32567 wxWindow *arg1 = (wxWindow *) 0 ;
32568 bool result;
32569 void *argp1 = 0 ;
32570 int res1 = 0 ;
32571 PyObject *swig_obj[1] ;
32572
32573 if (!args) SWIG_fail;
32574 swig_obj[0] = args;
32575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32576 if (!SWIG_IsOK(res1)) {
32577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
32578 }
32579 arg1 = reinterpret_cast< wxWindow * >(argp1);
32580 {
32581 PyThreadState* __tstate = wxPyBeginAllowThreads();
32582 result = (bool)((wxWindow const *)arg1)->IsShown();
32583 wxPyEndAllowThreads(__tstate);
32584 if (PyErr_Occurred()) SWIG_fail;
32585 }
32586 {
32587 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32588 }
32589 return resultobj;
32590 fail:
32591 return NULL;
32592 }
32593
32594
32595 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32596 PyObject *resultobj = 0;
32597 wxWindow *arg1 = (wxWindow *) 0 ;
32598 bool result;
32599 void *argp1 = 0 ;
32600 int res1 = 0 ;
32601 PyObject *swig_obj[1] ;
32602
32603 if (!args) SWIG_fail;
32604 swig_obj[0] = args;
32605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32606 if (!SWIG_IsOK(res1)) {
32607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32608 }
32609 arg1 = reinterpret_cast< wxWindow * >(argp1);
32610 {
32611 PyThreadState* __tstate = wxPyBeginAllowThreads();
32612 result = (bool)((wxWindow const *)arg1)->IsEnabled();
32613 wxPyEndAllowThreads(__tstate);
32614 if (PyErr_Occurred()) SWIG_fail;
32615 }
32616 {
32617 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32618 }
32619 return resultobj;
32620 fail:
32621 return NULL;
32622 }
32623
32624
32625 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32626 PyObject *resultobj = 0;
32627 wxWindow *arg1 = (wxWindow *) 0 ;
32628 long arg2 ;
32629 void *argp1 = 0 ;
32630 int res1 = 0 ;
32631 long val2 ;
32632 int ecode2 = 0 ;
32633 PyObject * obj0 = 0 ;
32634 PyObject * obj1 = 0 ;
32635 char * kwnames[] = {
32636 (char *) "self",(char *) "style", NULL
32637 };
32638
32639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32641 if (!SWIG_IsOK(res1)) {
32642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
32643 }
32644 arg1 = reinterpret_cast< wxWindow * >(argp1);
32645 ecode2 = SWIG_AsVal_long(obj1, &val2);
32646 if (!SWIG_IsOK(ecode2)) {
32647 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
32648 }
32649 arg2 = static_cast< long >(val2);
32650 {
32651 PyThreadState* __tstate = wxPyBeginAllowThreads();
32652 (arg1)->SetWindowStyleFlag(arg2);
32653 wxPyEndAllowThreads(__tstate);
32654 if (PyErr_Occurred()) SWIG_fail;
32655 }
32656 resultobj = SWIG_Py_Void();
32657 return resultobj;
32658 fail:
32659 return NULL;
32660 }
32661
32662
32663 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32664 PyObject *resultobj = 0;
32665 wxWindow *arg1 = (wxWindow *) 0 ;
32666 long result;
32667 void *argp1 = 0 ;
32668 int res1 = 0 ;
32669 PyObject *swig_obj[1] ;
32670
32671 if (!args) SWIG_fail;
32672 swig_obj[0] = args;
32673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32674 if (!SWIG_IsOK(res1)) {
32675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32676 }
32677 arg1 = reinterpret_cast< wxWindow * >(argp1);
32678 {
32679 PyThreadState* __tstate = wxPyBeginAllowThreads();
32680 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
32681 wxPyEndAllowThreads(__tstate);
32682 if (PyErr_Occurred()) SWIG_fail;
32683 }
32684 resultobj = SWIG_From_long(static_cast< long >(result));
32685 return resultobj;
32686 fail:
32687 return NULL;
32688 }
32689
32690
32691 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32692 PyObject *resultobj = 0;
32693 wxWindow *arg1 = (wxWindow *) 0 ;
32694 int arg2 ;
32695 bool result;
32696 void *argp1 = 0 ;
32697 int res1 = 0 ;
32698 int val2 ;
32699 int ecode2 = 0 ;
32700 PyObject * obj0 = 0 ;
32701 PyObject * obj1 = 0 ;
32702 char * kwnames[] = {
32703 (char *) "self",(char *) "flag", NULL
32704 };
32705
32706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32708 if (!SWIG_IsOK(res1)) {
32709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32710 }
32711 arg1 = reinterpret_cast< wxWindow * >(argp1);
32712 ecode2 = SWIG_AsVal_int(obj1, &val2);
32713 if (!SWIG_IsOK(ecode2)) {
32714 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
32715 }
32716 arg2 = static_cast< int >(val2);
32717 {
32718 PyThreadState* __tstate = wxPyBeginAllowThreads();
32719 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
32720 wxPyEndAllowThreads(__tstate);
32721 if (PyErr_Occurred()) SWIG_fail;
32722 }
32723 {
32724 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32725 }
32726 return resultobj;
32727 fail:
32728 return NULL;
32729 }
32730
32731
32732 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32733 PyObject *resultobj = 0;
32734 wxWindow *arg1 = (wxWindow *) 0 ;
32735 bool result;
32736 void *argp1 = 0 ;
32737 int res1 = 0 ;
32738 PyObject *swig_obj[1] ;
32739
32740 if (!args) SWIG_fail;
32741 swig_obj[0] = args;
32742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32743 if (!SWIG_IsOK(res1)) {
32744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
32745 }
32746 arg1 = reinterpret_cast< wxWindow * >(argp1);
32747 {
32748 PyThreadState* __tstate = wxPyBeginAllowThreads();
32749 result = (bool)((wxWindow const *)arg1)->IsRetained();
32750 wxPyEndAllowThreads(__tstate);
32751 if (PyErr_Occurred()) SWIG_fail;
32752 }
32753 {
32754 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32755 }
32756 return resultobj;
32757 fail:
32758 return NULL;
32759 }
32760
32761
32762 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32763 PyObject *resultobj = 0;
32764 wxWindow *arg1 = (wxWindow *) 0 ;
32765 long arg2 ;
32766 void *argp1 = 0 ;
32767 int res1 = 0 ;
32768 long val2 ;
32769 int ecode2 = 0 ;
32770 PyObject * obj0 = 0 ;
32771 PyObject * obj1 = 0 ;
32772 char * kwnames[] = {
32773 (char *) "self",(char *) "exStyle", NULL
32774 };
32775
32776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
32777 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32778 if (!SWIG_IsOK(res1)) {
32779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
32780 }
32781 arg1 = reinterpret_cast< wxWindow * >(argp1);
32782 ecode2 = SWIG_AsVal_long(obj1, &val2);
32783 if (!SWIG_IsOK(ecode2)) {
32784 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
32785 }
32786 arg2 = static_cast< long >(val2);
32787 {
32788 PyThreadState* __tstate = wxPyBeginAllowThreads();
32789 (arg1)->SetExtraStyle(arg2);
32790 wxPyEndAllowThreads(__tstate);
32791 if (PyErr_Occurred()) SWIG_fail;
32792 }
32793 resultobj = SWIG_Py_Void();
32794 return resultobj;
32795 fail:
32796 return NULL;
32797 }
32798
32799
32800 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32801 PyObject *resultobj = 0;
32802 wxWindow *arg1 = (wxWindow *) 0 ;
32803 long result;
32804 void *argp1 = 0 ;
32805 int res1 = 0 ;
32806 PyObject *swig_obj[1] ;
32807
32808 if (!args) SWIG_fail;
32809 swig_obj[0] = args;
32810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32811 if (!SWIG_IsOK(res1)) {
32812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
32813 }
32814 arg1 = reinterpret_cast< wxWindow * >(argp1);
32815 {
32816 PyThreadState* __tstate = wxPyBeginAllowThreads();
32817 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
32818 wxPyEndAllowThreads(__tstate);
32819 if (PyErr_Occurred()) SWIG_fail;
32820 }
32821 resultobj = SWIG_From_long(static_cast< long >(result));
32822 return resultobj;
32823 fail:
32824 return NULL;
32825 }
32826
32827
32828 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32829 PyObject *resultobj = 0;
32830 wxWindow *arg1 = (wxWindow *) 0 ;
32831 bool arg2 = (bool) true ;
32832 void *argp1 = 0 ;
32833 int res1 = 0 ;
32834 bool val2 ;
32835 int ecode2 = 0 ;
32836 PyObject * obj0 = 0 ;
32837 PyObject * obj1 = 0 ;
32838 char * kwnames[] = {
32839 (char *) "self",(char *) "modal", NULL
32840 };
32841
32842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
32843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32844 if (!SWIG_IsOK(res1)) {
32845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
32846 }
32847 arg1 = reinterpret_cast< wxWindow * >(argp1);
32848 if (obj1) {
32849 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32850 if (!SWIG_IsOK(ecode2)) {
32851 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
32852 }
32853 arg2 = static_cast< bool >(val2);
32854 }
32855 {
32856 PyThreadState* __tstate = wxPyBeginAllowThreads();
32857 (arg1)->MakeModal(arg2);
32858 wxPyEndAllowThreads(__tstate);
32859 if (PyErr_Occurred()) SWIG_fail;
32860 }
32861 resultobj = SWIG_Py_Void();
32862 return resultobj;
32863 fail:
32864 return NULL;
32865 }
32866
32867
32868 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32869 PyObject *resultobj = 0;
32870 wxWindow *arg1 = (wxWindow *) 0 ;
32871 bool arg2 ;
32872 void *argp1 = 0 ;
32873 int res1 = 0 ;
32874 bool val2 ;
32875 int ecode2 = 0 ;
32876 PyObject * obj0 = 0 ;
32877 PyObject * obj1 = 0 ;
32878 char * kwnames[] = {
32879 (char *) "self",(char *) "enableTheme", NULL
32880 };
32881
32882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
32883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32884 if (!SWIG_IsOK(res1)) {
32885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
32886 }
32887 arg1 = reinterpret_cast< wxWindow * >(argp1);
32888 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32889 if (!SWIG_IsOK(ecode2)) {
32890 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
32891 }
32892 arg2 = static_cast< bool >(val2);
32893 {
32894 PyThreadState* __tstate = wxPyBeginAllowThreads();
32895 (arg1)->SetThemeEnabled(arg2);
32896 wxPyEndAllowThreads(__tstate);
32897 if (PyErr_Occurred()) SWIG_fail;
32898 }
32899 resultobj = SWIG_Py_Void();
32900 return resultobj;
32901 fail:
32902 return NULL;
32903 }
32904
32905
32906 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32907 PyObject *resultobj = 0;
32908 wxWindow *arg1 = (wxWindow *) 0 ;
32909 bool result;
32910 void *argp1 = 0 ;
32911 int res1 = 0 ;
32912 PyObject *swig_obj[1] ;
32913
32914 if (!args) SWIG_fail;
32915 swig_obj[0] = args;
32916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32917 if (!SWIG_IsOK(res1)) {
32918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32919 }
32920 arg1 = reinterpret_cast< wxWindow * >(argp1);
32921 {
32922 PyThreadState* __tstate = wxPyBeginAllowThreads();
32923 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
32924 wxPyEndAllowThreads(__tstate);
32925 if (PyErr_Occurred()) SWIG_fail;
32926 }
32927 {
32928 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32929 }
32930 return resultobj;
32931 fail:
32932 return NULL;
32933 }
32934
32935
32936 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32937 PyObject *resultobj = 0;
32938 wxWindow *arg1 = (wxWindow *) 0 ;
32939 void *argp1 = 0 ;
32940 int res1 = 0 ;
32941 PyObject *swig_obj[1] ;
32942
32943 if (!args) SWIG_fail;
32944 swig_obj[0] = args;
32945 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32946 if (!SWIG_IsOK(res1)) {
32947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
32948 }
32949 arg1 = reinterpret_cast< wxWindow * >(argp1);
32950 {
32951 PyThreadState* __tstate = wxPyBeginAllowThreads();
32952 (arg1)->SetFocus();
32953 wxPyEndAllowThreads(__tstate);
32954 if (PyErr_Occurred()) SWIG_fail;
32955 }
32956 resultobj = SWIG_Py_Void();
32957 return resultobj;
32958 fail:
32959 return NULL;
32960 }
32961
32962
32963 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32964 PyObject *resultobj = 0;
32965 wxWindow *arg1 = (wxWindow *) 0 ;
32966 void *argp1 = 0 ;
32967 int res1 = 0 ;
32968 PyObject *swig_obj[1] ;
32969
32970 if (!args) SWIG_fail;
32971 swig_obj[0] = args;
32972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32973 if (!SWIG_IsOK(res1)) {
32974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
32975 }
32976 arg1 = reinterpret_cast< wxWindow * >(argp1);
32977 {
32978 PyThreadState* __tstate = wxPyBeginAllowThreads();
32979 (arg1)->SetFocusFromKbd();
32980 wxPyEndAllowThreads(__tstate);
32981 if (PyErr_Occurred()) SWIG_fail;
32982 }
32983 resultobj = SWIG_Py_Void();
32984 return resultobj;
32985 fail:
32986 return NULL;
32987 }
32988
32989
32990 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32991 PyObject *resultobj = 0;
32992 wxWindow *result = 0 ;
32993
32994 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
32995 {
32996 if (!wxPyCheckForApp()) SWIG_fail;
32997 PyThreadState* __tstate = wxPyBeginAllowThreads();
32998 result = (wxWindow *)wxWindow::FindFocus();
32999 wxPyEndAllowThreads(__tstate);
33000 if (PyErr_Occurred()) SWIG_fail;
33001 }
33002 {
33003 resultobj = wxPyMake_wxObject(result, 0);
33004 }
33005 return resultobj;
33006 fail:
33007 return NULL;
33008 }
33009
33010
33011 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33012 PyObject *resultobj = 0;
33013 wxWindow *arg1 = (wxWindow *) 0 ;
33014 bool result;
33015 void *argp1 = 0 ;
33016 int res1 = 0 ;
33017 PyObject *swig_obj[1] ;
33018
33019 if (!args) SWIG_fail;
33020 swig_obj[0] = args;
33021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33022 if (!SWIG_IsOK(res1)) {
33023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
33024 }
33025 arg1 = reinterpret_cast< wxWindow * >(argp1);
33026 {
33027 PyThreadState* __tstate = wxPyBeginAllowThreads();
33028 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
33029 wxPyEndAllowThreads(__tstate);
33030 if (PyErr_Occurred()) SWIG_fail;
33031 }
33032 {
33033 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33034 }
33035 return resultobj;
33036 fail:
33037 return NULL;
33038 }
33039
33040
33041 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33042 PyObject *resultobj = 0;
33043 wxWindow *arg1 = (wxWindow *) 0 ;
33044 bool result;
33045 void *argp1 = 0 ;
33046 int res1 = 0 ;
33047 PyObject *swig_obj[1] ;
33048
33049 if (!args) SWIG_fail;
33050 swig_obj[0] = args;
33051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33052 if (!SWIG_IsOK(res1)) {
33053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
33054 }
33055 arg1 = reinterpret_cast< wxWindow * >(argp1);
33056 {
33057 PyThreadState* __tstate = wxPyBeginAllowThreads();
33058 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
33059 wxPyEndAllowThreads(__tstate);
33060 if (PyErr_Occurred()) SWIG_fail;
33061 }
33062 {
33063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33064 }
33065 return resultobj;
33066 fail:
33067 return NULL;
33068 }
33069
33070
33071 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33072 PyObject *resultobj = 0;
33073 wxWindow *arg1 = (wxWindow *) 0 ;
33074 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
33075 bool result;
33076 void *argp1 = 0 ;
33077 int res1 = 0 ;
33078 int val2 ;
33079 int ecode2 = 0 ;
33080 PyObject * obj0 = 0 ;
33081 PyObject * obj1 = 0 ;
33082 char * kwnames[] = {
33083 (char *) "self",(char *) "flags", NULL
33084 };
33085
33086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
33087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33088 if (!SWIG_IsOK(res1)) {
33089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
33090 }
33091 arg1 = reinterpret_cast< wxWindow * >(argp1);
33092 if (obj1) {
33093 ecode2 = SWIG_AsVal_int(obj1, &val2);
33094 if (!SWIG_IsOK(ecode2)) {
33095 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
33096 }
33097 arg2 = static_cast< int >(val2);
33098 }
33099 {
33100 PyThreadState* __tstate = wxPyBeginAllowThreads();
33101 result = (bool)(arg1)->Navigate(arg2);
33102 wxPyEndAllowThreads(__tstate);
33103 if (PyErr_Occurred()) SWIG_fail;
33104 }
33105 {
33106 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33107 }
33108 return resultobj;
33109 fail:
33110 return NULL;
33111 }
33112
33113
33114 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33115 PyObject *resultobj = 0;
33116 wxWindow *arg1 = (wxWindow *) 0 ;
33117 wxWindow *arg2 = (wxWindow *) 0 ;
33118 void *argp1 = 0 ;
33119 int res1 = 0 ;
33120 void *argp2 = 0 ;
33121 int res2 = 0 ;
33122 PyObject * obj0 = 0 ;
33123 PyObject * obj1 = 0 ;
33124 char * kwnames[] = {
33125 (char *) "self",(char *) "win", NULL
33126 };
33127
33128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33130 if (!SWIG_IsOK(res1)) {
33131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33132 }
33133 arg1 = reinterpret_cast< wxWindow * >(argp1);
33134 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33135 if (!SWIG_IsOK(res2)) {
33136 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33137 }
33138 arg2 = reinterpret_cast< wxWindow * >(argp2);
33139 {
33140 PyThreadState* __tstate = wxPyBeginAllowThreads();
33141 (arg1)->MoveAfterInTabOrder(arg2);
33142 wxPyEndAllowThreads(__tstate);
33143 if (PyErr_Occurred()) SWIG_fail;
33144 }
33145 resultobj = SWIG_Py_Void();
33146 return resultobj;
33147 fail:
33148 return NULL;
33149 }
33150
33151
33152 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33153 PyObject *resultobj = 0;
33154 wxWindow *arg1 = (wxWindow *) 0 ;
33155 wxWindow *arg2 = (wxWindow *) 0 ;
33156 void *argp1 = 0 ;
33157 int res1 = 0 ;
33158 void *argp2 = 0 ;
33159 int res2 = 0 ;
33160 PyObject * obj0 = 0 ;
33161 PyObject * obj1 = 0 ;
33162 char * kwnames[] = {
33163 (char *) "self",(char *) "win", NULL
33164 };
33165
33166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33168 if (!SWIG_IsOK(res1)) {
33169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33170 }
33171 arg1 = reinterpret_cast< wxWindow * >(argp1);
33172 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33173 if (!SWIG_IsOK(res2)) {
33174 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33175 }
33176 arg2 = reinterpret_cast< wxWindow * >(argp2);
33177 {
33178 PyThreadState* __tstate = wxPyBeginAllowThreads();
33179 (arg1)->MoveBeforeInTabOrder(arg2);
33180 wxPyEndAllowThreads(__tstate);
33181 if (PyErr_Occurred()) SWIG_fail;
33182 }
33183 resultobj = SWIG_Py_Void();
33184 return resultobj;
33185 fail:
33186 return NULL;
33187 }
33188
33189
33190 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33191 PyObject *resultobj = 0;
33192 wxWindow *arg1 = (wxWindow *) 0 ;
33193 PyObject *result = 0 ;
33194 void *argp1 = 0 ;
33195 int res1 = 0 ;
33196 PyObject *swig_obj[1] ;
33197
33198 if (!args) SWIG_fail;
33199 swig_obj[0] = args;
33200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33201 if (!SWIG_IsOK(res1)) {
33202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
33203 }
33204 arg1 = reinterpret_cast< wxWindow * >(argp1);
33205 {
33206 PyThreadState* __tstate = wxPyBeginAllowThreads();
33207 result = (PyObject *)wxWindow_GetChildren(arg1);
33208 wxPyEndAllowThreads(__tstate);
33209 if (PyErr_Occurred()) SWIG_fail;
33210 }
33211 resultobj = result;
33212 return resultobj;
33213 fail:
33214 return NULL;
33215 }
33216
33217
33218 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33219 PyObject *resultobj = 0;
33220 wxWindow *arg1 = (wxWindow *) 0 ;
33221 wxWindow *result = 0 ;
33222 void *argp1 = 0 ;
33223 int res1 = 0 ;
33224 PyObject *swig_obj[1] ;
33225
33226 if (!args) SWIG_fail;
33227 swig_obj[0] = args;
33228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33229 if (!SWIG_IsOK(res1)) {
33230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33231 }
33232 arg1 = reinterpret_cast< wxWindow * >(argp1);
33233 {
33234 PyThreadState* __tstate = wxPyBeginAllowThreads();
33235 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
33236 wxPyEndAllowThreads(__tstate);
33237 if (PyErr_Occurred()) SWIG_fail;
33238 }
33239 {
33240 resultobj = wxPyMake_wxObject(result, 0);
33241 }
33242 return resultobj;
33243 fail:
33244 return NULL;
33245 }
33246
33247
33248 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33249 PyObject *resultobj = 0;
33250 wxWindow *arg1 = (wxWindow *) 0 ;
33251 wxWindow *result = 0 ;
33252 void *argp1 = 0 ;
33253 int res1 = 0 ;
33254 PyObject *swig_obj[1] ;
33255
33256 if (!args) SWIG_fail;
33257 swig_obj[0] = args;
33258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33259 if (!SWIG_IsOK(res1)) {
33260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33261 }
33262 arg1 = reinterpret_cast< wxWindow * >(argp1);
33263 {
33264 PyThreadState* __tstate = wxPyBeginAllowThreads();
33265 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
33266 wxPyEndAllowThreads(__tstate);
33267 if (PyErr_Occurred()) SWIG_fail;
33268 }
33269 {
33270 resultobj = wxPyMake_wxObject(result, 0);
33271 }
33272 return resultobj;
33273 fail:
33274 return NULL;
33275 }
33276
33277
33278 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33279 PyObject *resultobj = 0;
33280 wxWindow *arg1 = (wxWindow *) 0 ;
33281 bool result;
33282 void *argp1 = 0 ;
33283 int res1 = 0 ;
33284 PyObject *swig_obj[1] ;
33285
33286 if (!args) SWIG_fail;
33287 swig_obj[0] = args;
33288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33289 if (!SWIG_IsOK(res1)) {
33290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33291 }
33292 arg1 = reinterpret_cast< wxWindow * >(argp1);
33293 {
33294 PyThreadState* __tstate = wxPyBeginAllowThreads();
33295 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
33296 wxPyEndAllowThreads(__tstate);
33297 if (PyErr_Occurred()) SWIG_fail;
33298 }
33299 {
33300 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33301 }
33302 return resultobj;
33303 fail:
33304 return NULL;
33305 }
33306
33307
33308 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33309 PyObject *resultobj = 0;
33310 wxWindow *arg1 = (wxWindow *) 0 ;
33311 wxWindow *arg2 = (wxWindow *) 0 ;
33312 bool result;
33313 void *argp1 = 0 ;
33314 int res1 = 0 ;
33315 void *argp2 = 0 ;
33316 int res2 = 0 ;
33317 PyObject * obj0 = 0 ;
33318 PyObject * obj1 = 0 ;
33319 char * kwnames[] = {
33320 (char *) "self",(char *) "newParent", NULL
33321 };
33322
33323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
33324 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33325 if (!SWIG_IsOK(res1)) {
33326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
33327 }
33328 arg1 = reinterpret_cast< wxWindow * >(argp1);
33329 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33330 if (!SWIG_IsOK(res2)) {
33331 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
33332 }
33333 arg2 = reinterpret_cast< wxWindow * >(argp2);
33334 {
33335 PyThreadState* __tstate = wxPyBeginAllowThreads();
33336 result = (bool)(arg1)->Reparent(arg2);
33337 wxPyEndAllowThreads(__tstate);
33338 if (PyErr_Occurred()) SWIG_fail;
33339 }
33340 {
33341 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33342 }
33343 return resultobj;
33344 fail:
33345 return NULL;
33346 }
33347
33348
33349 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33350 PyObject *resultobj = 0;
33351 wxWindow *arg1 = (wxWindow *) 0 ;
33352 wxWindow *arg2 = (wxWindow *) 0 ;
33353 void *argp1 = 0 ;
33354 int res1 = 0 ;
33355 void *argp2 = 0 ;
33356 int res2 = 0 ;
33357 PyObject * obj0 = 0 ;
33358 PyObject * obj1 = 0 ;
33359 char * kwnames[] = {
33360 (char *) "self",(char *) "child", NULL
33361 };
33362
33363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
33364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33365 if (!SWIG_IsOK(res1)) {
33366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33367 }
33368 arg1 = reinterpret_cast< wxWindow * >(argp1);
33369 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33370 if (!SWIG_IsOK(res2)) {
33371 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33372 }
33373 arg2 = reinterpret_cast< wxWindow * >(argp2);
33374 {
33375 PyThreadState* __tstate = wxPyBeginAllowThreads();
33376 (arg1)->AddChild(arg2);
33377 wxPyEndAllowThreads(__tstate);
33378 if (PyErr_Occurred()) SWIG_fail;
33379 }
33380 resultobj = SWIG_Py_Void();
33381 return resultobj;
33382 fail:
33383 return NULL;
33384 }
33385
33386
33387 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33388 PyObject *resultobj = 0;
33389 wxWindow *arg1 = (wxWindow *) 0 ;
33390 wxWindow *arg2 = (wxWindow *) 0 ;
33391 void *argp1 = 0 ;
33392 int res1 = 0 ;
33393 void *argp2 = 0 ;
33394 int res2 = 0 ;
33395 PyObject * obj0 = 0 ;
33396 PyObject * obj1 = 0 ;
33397 char * kwnames[] = {
33398 (char *) "self",(char *) "child", NULL
33399 };
33400
33401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
33402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33403 if (!SWIG_IsOK(res1)) {
33404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33405 }
33406 arg1 = reinterpret_cast< wxWindow * >(argp1);
33407 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33408 if (!SWIG_IsOK(res2)) {
33409 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33410 }
33411 arg2 = reinterpret_cast< wxWindow * >(argp2);
33412 {
33413 PyThreadState* __tstate = wxPyBeginAllowThreads();
33414 (arg1)->RemoveChild(arg2);
33415 wxPyEndAllowThreads(__tstate);
33416 if (PyErr_Occurred()) SWIG_fail;
33417 }
33418 resultobj = SWIG_Py_Void();
33419 return resultobj;
33420 fail:
33421 return NULL;
33422 }
33423
33424
33425 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33426 PyObject *resultobj = 0;
33427 wxWindow *arg1 = (wxWindow *) 0 ;
33428 bool arg2 ;
33429 void *argp1 = 0 ;
33430 int res1 = 0 ;
33431 bool val2 ;
33432 int ecode2 = 0 ;
33433 PyObject * obj0 = 0 ;
33434 PyObject * obj1 = 0 ;
33435 char * kwnames[] = {
33436 (char *) "self",(char *) "on", NULL
33437 };
33438
33439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
33440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33441 if (!SWIG_IsOK(res1)) {
33442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
33443 }
33444 arg1 = reinterpret_cast< wxWindow * >(argp1);
33445 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33446 if (!SWIG_IsOK(ecode2)) {
33447 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
33448 }
33449 arg2 = static_cast< bool >(val2);
33450 {
33451 PyThreadState* __tstate = wxPyBeginAllowThreads();
33452 wxWindow_SetDoubleBuffered(arg1,arg2);
33453 wxPyEndAllowThreads(__tstate);
33454 if (PyErr_Occurred()) SWIG_fail;
33455 }
33456 resultobj = SWIG_Py_Void();
33457 return resultobj;
33458 fail:
33459 return NULL;
33460 }
33461
33462
33463 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33464 PyObject *resultobj = 0;
33465 wxWindow *arg1 = (wxWindow *) 0 ;
33466 long arg2 ;
33467 wxWindow *result = 0 ;
33468 void *argp1 = 0 ;
33469 int res1 = 0 ;
33470 long val2 ;
33471 int ecode2 = 0 ;
33472 PyObject * obj0 = 0 ;
33473 PyObject * obj1 = 0 ;
33474 char * kwnames[] = {
33475 (char *) "self",(char *) "winid", NULL
33476 };
33477
33478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
33479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33480 if (!SWIG_IsOK(res1)) {
33481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
33482 }
33483 arg1 = reinterpret_cast< wxWindow * >(argp1);
33484 ecode2 = SWIG_AsVal_long(obj1, &val2);
33485 if (!SWIG_IsOK(ecode2)) {
33486 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
33487 }
33488 arg2 = static_cast< long >(val2);
33489 {
33490 PyThreadState* __tstate = wxPyBeginAllowThreads();
33491 result = (wxWindow *)(arg1)->FindWindow(arg2);
33492 wxPyEndAllowThreads(__tstate);
33493 if (PyErr_Occurred()) SWIG_fail;
33494 }
33495 {
33496 resultobj = wxPyMake_wxObject(result, 0);
33497 }
33498 return resultobj;
33499 fail:
33500 return NULL;
33501 }
33502
33503
33504 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33505 PyObject *resultobj = 0;
33506 wxWindow *arg1 = (wxWindow *) 0 ;
33507 wxString *arg2 = 0 ;
33508 wxWindow *result = 0 ;
33509 void *argp1 = 0 ;
33510 int res1 = 0 ;
33511 bool temp2 = false ;
33512 PyObject * obj0 = 0 ;
33513 PyObject * obj1 = 0 ;
33514 char * kwnames[] = {
33515 (char *) "self",(char *) "name", NULL
33516 };
33517
33518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
33519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33520 if (!SWIG_IsOK(res1)) {
33521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
33522 }
33523 arg1 = reinterpret_cast< wxWindow * >(argp1);
33524 {
33525 arg2 = wxString_in_helper(obj1);
33526 if (arg2 == NULL) SWIG_fail;
33527 temp2 = true;
33528 }
33529 {
33530 PyThreadState* __tstate = wxPyBeginAllowThreads();
33531 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
33532 wxPyEndAllowThreads(__tstate);
33533 if (PyErr_Occurred()) SWIG_fail;
33534 }
33535 {
33536 resultobj = wxPyMake_wxObject(result, 0);
33537 }
33538 {
33539 if (temp2)
33540 delete arg2;
33541 }
33542 return resultobj;
33543 fail:
33544 {
33545 if (temp2)
33546 delete arg2;
33547 }
33548 return NULL;
33549 }
33550
33551
33552 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33553 PyObject *resultobj = 0;
33554 wxWindow *arg1 = (wxWindow *) 0 ;
33555 wxEvtHandler *result = 0 ;
33556 void *argp1 = 0 ;
33557 int res1 = 0 ;
33558 PyObject *swig_obj[1] ;
33559
33560 if (!args) SWIG_fail;
33561 swig_obj[0] = args;
33562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33563 if (!SWIG_IsOK(res1)) {
33564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
33565 }
33566 arg1 = reinterpret_cast< wxWindow * >(argp1);
33567 {
33568 PyThreadState* __tstate = wxPyBeginAllowThreads();
33569 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
33570 wxPyEndAllowThreads(__tstate);
33571 if (PyErr_Occurred()) SWIG_fail;
33572 }
33573 {
33574 resultobj = wxPyMake_wxObject(result, 0);
33575 }
33576 return resultobj;
33577 fail:
33578 return NULL;
33579 }
33580
33581
33582 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33583 PyObject *resultobj = 0;
33584 wxWindow *arg1 = (wxWindow *) 0 ;
33585 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33586 void *argp1 = 0 ;
33587 int res1 = 0 ;
33588 void *argp2 = 0 ;
33589 int res2 = 0 ;
33590 PyObject * obj0 = 0 ;
33591 PyObject * obj1 = 0 ;
33592 char * kwnames[] = {
33593 (char *) "self",(char *) "handler", NULL
33594 };
33595
33596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33598 if (!SWIG_IsOK(res1)) {
33599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33600 }
33601 arg1 = reinterpret_cast< wxWindow * >(argp1);
33602 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33603 if (!SWIG_IsOK(res2)) {
33604 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33605 }
33606 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33607 {
33608 PyThreadState* __tstate = wxPyBeginAllowThreads();
33609 (arg1)->SetEventHandler(arg2);
33610 wxPyEndAllowThreads(__tstate);
33611 if (PyErr_Occurred()) SWIG_fail;
33612 }
33613 resultobj = SWIG_Py_Void();
33614 return resultobj;
33615 fail:
33616 return NULL;
33617 }
33618
33619
33620 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33621 PyObject *resultobj = 0;
33622 wxWindow *arg1 = (wxWindow *) 0 ;
33623 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33624 void *argp1 = 0 ;
33625 int res1 = 0 ;
33626 void *argp2 = 0 ;
33627 int res2 = 0 ;
33628 PyObject * obj0 = 0 ;
33629 PyObject * obj1 = 0 ;
33630 char * kwnames[] = {
33631 (char *) "self",(char *) "handler", NULL
33632 };
33633
33634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33636 if (!SWIG_IsOK(res1)) {
33637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33638 }
33639 arg1 = reinterpret_cast< wxWindow * >(argp1);
33640 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33641 if (!SWIG_IsOK(res2)) {
33642 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33643 }
33644 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33645 {
33646 PyThreadState* __tstate = wxPyBeginAllowThreads();
33647 (arg1)->PushEventHandler(arg2);
33648 wxPyEndAllowThreads(__tstate);
33649 if (PyErr_Occurred()) SWIG_fail;
33650 }
33651 resultobj = SWIG_Py_Void();
33652 return resultobj;
33653 fail:
33654 return NULL;
33655 }
33656
33657
33658 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33659 PyObject *resultobj = 0;
33660 wxWindow *arg1 = (wxWindow *) 0 ;
33661 bool arg2 = (bool) false ;
33662 wxEvtHandler *result = 0 ;
33663 void *argp1 = 0 ;
33664 int res1 = 0 ;
33665 bool val2 ;
33666 int ecode2 = 0 ;
33667 PyObject * obj0 = 0 ;
33668 PyObject * obj1 = 0 ;
33669 char * kwnames[] = {
33670 (char *) "self",(char *) "deleteHandler", NULL
33671 };
33672
33673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33675 if (!SWIG_IsOK(res1)) {
33676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33677 }
33678 arg1 = reinterpret_cast< wxWindow * >(argp1);
33679 if (obj1) {
33680 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33681 if (!SWIG_IsOK(ecode2)) {
33682 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
33683 }
33684 arg2 = static_cast< bool >(val2);
33685 }
33686 {
33687 PyThreadState* __tstate = wxPyBeginAllowThreads();
33688 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
33689 wxPyEndAllowThreads(__tstate);
33690 if (PyErr_Occurred()) SWIG_fail;
33691 }
33692 {
33693 resultobj = wxPyMake_wxObject(result, 0);
33694 }
33695 return resultobj;
33696 fail:
33697 return NULL;
33698 }
33699
33700
33701 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33702 PyObject *resultobj = 0;
33703 wxWindow *arg1 = (wxWindow *) 0 ;
33704 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33705 bool result;
33706 void *argp1 = 0 ;
33707 int res1 = 0 ;
33708 void *argp2 = 0 ;
33709 int res2 = 0 ;
33710 PyObject * obj0 = 0 ;
33711 PyObject * obj1 = 0 ;
33712 char * kwnames[] = {
33713 (char *) "self",(char *) "handler", NULL
33714 };
33715
33716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33718 if (!SWIG_IsOK(res1)) {
33719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33720 }
33721 arg1 = reinterpret_cast< wxWindow * >(argp1);
33722 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33723 if (!SWIG_IsOK(res2)) {
33724 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33725 }
33726 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33727 {
33728 PyThreadState* __tstate = wxPyBeginAllowThreads();
33729 result = (bool)(arg1)->RemoveEventHandler(arg2);
33730 wxPyEndAllowThreads(__tstate);
33731 if (PyErr_Occurred()) SWIG_fail;
33732 }
33733 {
33734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33735 }
33736 return resultobj;
33737 fail:
33738 return NULL;
33739 }
33740
33741
33742 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33743 PyObject *resultobj = 0;
33744 wxWindow *arg1 = (wxWindow *) 0 ;
33745 wxValidator *arg2 = 0 ;
33746 void *argp1 = 0 ;
33747 int res1 = 0 ;
33748 void *argp2 = 0 ;
33749 int res2 = 0 ;
33750 PyObject * obj0 = 0 ;
33751 PyObject * obj1 = 0 ;
33752 char * kwnames[] = {
33753 (char *) "self",(char *) "validator", NULL
33754 };
33755
33756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
33757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33758 if (!SWIG_IsOK(res1)) {
33759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33760 }
33761 arg1 = reinterpret_cast< wxWindow * >(argp1);
33762 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
33763 if (!SWIG_IsOK(res2)) {
33764 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33765 }
33766 if (!argp2) {
33767 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33768 }
33769 arg2 = reinterpret_cast< wxValidator * >(argp2);
33770 {
33771 PyThreadState* __tstate = wxPyBeginAllowThreads();
33772 (arg1)->SetValidator((wxValidator const &)*arg2);
33773 wxPyEndAllowThreads(__tstate);
33774 if (PyErr_Occurred()) SWIG_fail;
33775 }
33776 resultobj = SWIG_Py_Void();
33777 return resultobj;
33778 fail:
33779 return NULL;
33780 }
33781
33782
33783 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33784 PyObject *resultobj = 0;
33785 wxWindow *arg1 = (wxWindow *) 0 ;
33786 wxValidator *result = 0 ;
33787 void *argp1 = 0 ;
33788 int res1 = 0 ;
33789 PyObject *swig_obj[1] ;
33790
33791 if (!args) SWIG_fail;
33792 swig_obj[0] = args;
33793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33794 if (!SWIG_IsOK(res1)) {
33795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33796 }
33797 arg1 = reinterpret_cast< wxWindow * >(argp1);
33798 {
33799 PyThreadState* __tstate = wxPyBeginAllowThreads();
33800 result = (wxValidator *)(arg1)->GetValidator();
33801 wxPyEndAllowThreads(__tstate);
33802 if (PyErr_Occurred()) SWIG_fail;
33803 }
33804 {
33805 resultobj = wxPyMake_wxObject(result, (bool)0);
33806 }
33807 return resultobj;
33808 fail:
33809 return NULL;
33810 }
33811
33812
33813 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33814 PyObject *resultobj = 0;
33815 wxWindow *arg1 = (wxWindow *) 0 ;
33816 bool result;
33817 void *argp1 = 0 ;
33818 int res1 = 0 ;
33819 PyObject *swig_obj[1] ;
33820
33821 if (!args) SWIG_fail;
33822 swig_obj[0] = args;
33823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33824 if (!SWIG_IsOK(res1)) {
33825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
33826 }
33827 arg1 = reinterpret_cast< wxWindow * >(argp1);
33828 {
33829 PyThreadState* __tstate = wxPyBeginAllowThreads();
33830 result = (bool)(arg1)->Validate();
33831 wxPyEndAllowThreads(__tstate);
33832 if (PyErr_Occurred()) SWIG_fail;
33833 }
33834 {
33835 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33836 }
33837 return resultobj;
33838 fail:
33839 return NULL;
33840 }
33841
33842
33843 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33844 PyObject *resultobj = 0;
33845 wxWindow *arg1 = (wxWindow *) 0 ;
33846 bool result;
33847 void *argp1 = 0 ;
33848 int res1 = 0 ;
33849 PyObject *swig_obj[1] ;
33850
33851 if (!args) SWIG_fail;
33852 swig_obj[0] = args;
33853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33854 if (!SWIG_IsOK(res1)) {
33855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33856 }
33857 arg1 = reinterpret_cast< wxWindow * >(argp1);
33858 {
33859 PyThreadState* __tstate = wxPyBeginAllowThreads();
33860 result = (bool)(arg1)->TransferDataToWindow();
33861 wxPyEndAllowThreads(__tstate);
33862 if (PyErr_Occurred()) SWIG_fail;
33863 }
33864 {
33865 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33866 }
33867 return resultobj;
33868 fail:
33869 return NULL;
33870 }
33871
33872
33873 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33874 PyObject *resultobj = 0;
33875 wxWindow *arg1 = (wxWindow *) 0 ;
33876 bool result;
33877 void *argp1 = 0 ;
33878 int res1 = 0 ;
33879 PyObject *swig_obj[1] ;
33880
33881 if (!args) SWIG_fail;
33882 swig_obj[0] = args;
33883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33884 if (!SWIG_IsOK(res1)) {
33885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33886 }
33887 arg1 = reinterpret_cast< wxWindow * >(argp1);
33888 {
33889 PyThreadState* __tstate = wxPyBeginAllowThreads();
33890 result = (bool)(arg1)->TransferDataFromWindow();
33891 wxPyEndAllowThreads(__tstate);
33892 if (PyErr_Occurred()) SWIG_fail;
33893 }
33894 {
33895 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33896 }
33897 return resultobj;
33898 fail:
33899 return NULL;
33900 }
33901
33902
33903 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33904 PyObject *resultobj = 0;
33905 wxWindow *arg1 = (wxWindow *) 0 ;
33906 void *argp1 = 0 ;
33907 int res1 = 0 ;
33908 PyObject *swig_obj[1] ;
33909
33910 if (!args) SWIG_fail;
33911 swig_obj[0] = args;
33912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33913 if (!SWIG_IsOK(res1)) {
33914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33915 }
33916 arg1 = reinterpret_cast< wxWindow * >(argp1);
33917 {
33918 PyThreadState* __tstate = wxPyBeginAllowThreads();
33919 (arg1)->InitDialog();
33920 wxPyEndAllowThreads(__tstate);
33921 if (PyErr_Occurred()) SWIG_fail;
33922 }
33923 resultobj = SWIG_Py_Void();
33924 return resultobj;
33925 fail:
33926 return NULL;
33927 }
33928
33929
33930 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33931 PyObject *resultobj = 0;
33932 wxWindow *arg1 = (wxWindow *) 0 ;
33933 wxAcceleratorTable *arg2 = 0 ;
33934 void *argp1 = 0 ;
33935 int res1 = 0 ;
33936 void *argp2 = 0 ;
33937 int res2 = 0 ;
33938 PyObject * obj0 = 0 ;
33939 PyObject * obj1 = 0 ;
33940 char * kwnames[] = {
33941 (char *) "self",(char *) "accel", NULL
33942 };
33943
33944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
33945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33946 if (!SWIG_IsOK(res1)) {
33947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33948 }
33949 arg1 = reinterpret_cast< wxWindow * >(argp1);
33950 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
33951 if (!SWIG_IsOK(res2)) {
33952 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33953 }
33954 if (!argp2) {
33955 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33956 }
33957 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
33958 {
33959 PyThreadState* __tstate = wxPyBeginAllowThreads();
33960 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
33961 wxPyEndAllowThreads(__tstate);
33962 if (PyErr_Occurred()) SWIG_fail;
33963 }
33964 resultobj = SWIG_Py_Void();
33965 return resultobj;
33966 fail:
33967 return NULL;
33968 }
33969
33970
33971 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33972 PyObject *resultobj = 0;
33973 wxWindow *arg1 = (wxWindow *) 0 ;
33974 wxAcceleratorTable *result = 0 ;
33975 void *argp1 = 0 ;
33976 int res1 = 0 ;
33977 PyObject *swig_obj[1] ;
33978
33979 if (!args) SWIG_fail;
33980 swig_obj[0] = args;
33981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33982 if (!SWIG_IsOK(res1)) {
33983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33984 }
33985 arg1 = reinterpret_cast< wxWindow * >(argp1);
33986 {
33987 PyThreadState* __tstate = wxPyBeginAllowThreads();
33988 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
33989 wxPyEndAllowThreads(__tstate);
33990 if (PyErr_Occurred()) SWIG_fail;
33991 }
33992 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
33993 return resultobj;
33994 fail:
33995 return NULL;
33996 }
33997
33998
33999 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34000 PyObject *resultobj = 0;
34001 wxWindow *arg1 = (wxWindow *) 0 ;
34002 int arg2 ;
34003 int arg3 ;
34004 int arg4 ;
34005 bool result;
34006 void *argp1 = 0 ;
34007 int res1 = 0 ;
34008 int val2 ;
34009 int ecode2 = 0 ;
34010 int val3 ;
34011 int ecode3 = 0 ;
34012 int val4 ;
34013 int ecode4 = 0 ;
34014 PyObject * obj0 = 0 ;
34015 PyObject * obj1 = 0 ;
34016 PyObject * obj2 = 0 ;
34017 PyObject * obj3 = 0 ;
34018 char * kwnames[] = {
34019 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
34020 };
34021
34022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34024 if (!SWIG_IsOK(res1)) {
34025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
34026 }
34027 arg1 = reinterpret_cast< wxWindow * >(argp1);
34028 ecode2 = SWIG_AsVal_int(obj1, &val2);
34029 if (!SWIG_IsOK(ecode2)) {
34030 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
34031 }
34032 arg2 = static_cast< int >(val2);
34033 ecode3 = SWIG_AsVal_int(obj2, &val3);
34034 if (!SWIG_IsOK(ecode3)) {
34035 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
34036 }
34037 arg3 = static_cast< int >(val3);
34038 ecode4 = SWIG_AsVal_int(obj3, &val4);
34039 if (!SWIG_IsOK(ecode4)) {
34040 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
34041 }
34042 arg4 = static_cast< int >(val4);
34043 {
34044 PyThreadState* __tstate = wxPyBeginAllowThreads();
34045 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
34046 wxPyEndAllowThreads(__tstate);
34047 if (PyErr_Occurred()) SWIG_fail;
34048 }
34049 {
34050 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34051 }
34052 return resultobj;
34053 fail:
34054 return NULL;
34055 }
34056
34057
34058 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34059 PyObject *resultobj = 0;
34060 wxWindow *arg1 = (wxWindow *) 0 ;
34061 int arg2 ;
34062 bool result;
34063 void *argp1 = 0 ;
34064 int res1 = 0 ;
34065 int val2 ;
34066 int ecode2 = 0 ;
34067 PyObject * obj0 = 0 ;
34068 PyObject * obj1 = 0 ;
34069 char * kwnames[] = {
34070 (char *) "self",(char *) "hotkeyId", NULL
34071 };
34072
34073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
34074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34075 if (!SWIG_IsOK(res1)) {
34076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
34077 }
34078 arg1 = reinterpret_cast< wxWindow * >(argp1);
34079 ecode2 = SWIG_AsVal_int(obj1, &val2);
34080 if (!SWIG_IsOK(ecode2)) {
34081 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
34082 }
34083 arg2 = static_cast< int >(val2);
34084 {
34085 PyThreadState* __tstate = wxPyBeginAllowThreads();
34086 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
34087 wxPyEndAllowThreads(__tstate);
34088 if (PyErr_Occurred()) SWIG_fail;
34089 }
34090 {
34091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34092 }
34093 return resultobj;
34094 fail:
34095 return NULL;
34096 }
34097
34098
34099 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34100 PyObject *resultobj = 0;
34101 wxWindow *arg1 = (wxWindow *) 0 ;
34102 wxPoint *arg2 = 0 ;
34103 wxPoint result;
34104 void *argp1 = 0 ;
34105 int res1 = 0 ;
34106 wxPoint temp2 ;
34107 PyObject * obj0 = 0 ;
34108 PyObject * obj1 = 0 ;
34109 char * kwnames[] = {
34110 (char *) "self",(char *) "pt", NULL
34111 };
34112
34113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
34114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34115 if (!SWIG_IsOK(res1)) {
34116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
34117 }
34118 arg1 = reinterpret_cast< wxWindow * >(argp1);
34119 {
34120 arg2 = &temp2;
34121 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34122 }
34123 {
34124 PyThreadState* __tstate = wxPyBeginAllowThreads();
34125 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34126 wxPyEndAllowThreads(__tstate);
34127 if (PyErr_Occurred()) SWIG_fail;
34128 }
34129 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34130 return resultobj;
34131 fail:
34132 return NULL;
34133 }
34134
34135
34136 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34137 PyObject *resultobj = 0;
34138 wxWindow *arg1 = (wxWindow *) 0 ;
34139 wxSize *arg2 = 0 ;
34140 wxSize result;
34141 void *argp1 = 0 ;
34142 int res1 = 0 ;
34143 wxSize temp2 ;
34144 PyObject * obj0 = 0 ;
34145 PyObject * obj1 = 0 ;
34146 char * kwnames[] = {
34147 (char *) "self",(char *) "sz", NULL
34148 };
34149
34150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
34151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34152 if (!SWIG_IsOK(res1)) {
34153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
34154 }
34155 arg1 = reinterpret_cast< wxWindow * >(argp1);
34156 {
34157 arg2 = &temp2;
34158 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34159 }
34160 {
34161 PyThreadState* __tstate = wxPyBeginAllowThreads();
34162 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34163 wxPyEndAllowThreads(__tstate);
34164 if (PyErr_Occurred()) SWIG_fail;
34165 }
34166 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34167 return resultobj;
34168 fail:
34169 return NULL;
34170 }
34171
34172
34173 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34174 PyObject *resultobj = 0;
34175 wxWindow *arg1 = (wxWindow *) 0 ;
34176 wxPoint *arg2 = 0 ;
34177 wxPoint result;
34178 void *argp1 = 0 ;
34179 int res1 = 0 ;
34180 wxPoint temp2 ;
34181 PyObject * obj0 = 0 ;
34182 PyObject * obj1 = 0 ;
34183 char * kwnames[] = {
34184 (char *) "self",(char *) "pt", NULL
34185 };
34186
34187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
34188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34189 if (!SWIG_IsOK(res1)) {
34190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
34191 }
34192 arg1 = reinterpret_cast< wxWindow * >(argp1);
34193 {
34194 arg2 = &temp2;
34195 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34196 }
34197 {
34198 PyThreadState* __tstate = wxPyBeginAllowThreads();
34199 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34200 wxPyEndAllowThreads(__tstate);
34201 if (PyErr_Occurred()) SWIG_fail;
34202 }
34203 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34204 return resultobj;
34205 fail:
34206 return NULL;
34207 }
34208
34209
34210 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34211 PyObject *resultobj = 0;
34212 wxWindow *arg1 = (wxWindow *) 0 ;
34213 wxSize *arg2 = 0 ;
34214 wxSize result;
34215 void *argp1 = 0 ;
34216 int res1 = 0 ;
34217 wxSize temp2 ;
34218 PyObject * obj0 = 0 ;
34219 PyObject * obj1 = 0 ;
34220 char * kwnames[] = {
34221 (char *) "self",(char *) "sz", NULL
34222 };
34223
34224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
34225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34226 if (!SWIG_IsOK(res1)) {
34227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
34228 }
34229 arg1 = reinterpret_cast< wxWindow * >(argp1);
34230 {
34231 arg2 = &temp2;
34232 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34233 }
34234 {
34235 PyThreadState* __tstate = wxPyBeginAllowThreads();
34236 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34237 wxPyEndAllowThreads(__tstate);
34238 if (PyErr_Occurred()) SWIG_fail;
34239 }
34240 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34241 return resultobj;
34242 fail:
34243 return NULL;
34244 }
34245
34246
34247 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34248 PyObject *resultobj = 0;
34249 wxWindow *arg1 = (wxWindow *) 0 ;
34250 wxPoint *arg2 = 0 ;
34251 wxPoint result;
34252 void *argp1 = 0 ;
34253 int res1 = 0 ;
34254 wxPoint temp2 ;
34255 PyObject * obj0 = 0 ;
34256 PyObject * obj1 = 0 ;
34257 char * kwnames[] = {
34258 (char *) "self",(char *) "pt", NULL
34259 };
34260
34261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34263 if (!SWIG_IsOK(res1)) {
34264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34265 }
34266 arg1 = reinterpret_cast< wxWindow * >(argp1);
34267 {
34268 arg2 = &temp2;
34269 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34270 }
34271 {
34272 PyThreadState* __tstate = wxPyBeginAllowThreads();
34273 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
34274 wxPyEndAllowThreads(__tstate);
34275 if (PyErr_Occurred()) SWIG_fail;
34276 }
34277 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34278 return resultobj;
34279 fail:
34280 return NULL;
34281 }
34282
34283
34284 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34285 PyObject *resultobj = 0;
34286 wxWindow *arg1 = (wxWindow *) 0 ;
34287 wxSize *arg2 = 0 ;
34288 wxSize result;
34289 void *argp1 = 0 ;
34290 int res1 = 0 ;
34291 wxSize temp2 ;
34292 PyObject * obj0 = 0 ;
34293 PyObject * obj1 = 0 ;
34294 char * kwnames[] = {
34295 (char *) "self",(char *) "sz", NULL
34296 };
34297
34298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34300 if (!SWIG_IsOK(res1)) {
34301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34302 }
34303 arg1 = reinterpret_cast< wxWindow * >(argp1);
34304 {
34305 arg2 = &temp2;
34306 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34307 }
34308 {
34309 PyThreadState* __tstate = wxPyBeginAllowThreads();
34310 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
34311 wxPyEndAllowThreads(__tstate);
34312 if (PyErr_Occurred()) SWIG_fail;
34313 }
34314 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34315 return resultobj;
34316 fail:
34317 return NULL;
34318 }
34319
34320
34321 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34322 PyObject *resultobj = 0;
34323 wxWindow *arg1 = (wxWindow *) 0 ;
34324 int arg2 ;
34325 int arg3 ;
34326 void *argp1 = 0 ;
34327 int res1 = 0 ;
34328 int val2 ;
34329 int ecode2 = 0 ;
34330 int val3 ;
34331 int ecode3 = 0 ;
34332 PyObject * obj0 = 0 ;
34333 PyObject * obj1 = 0 ;
34334 PyObject * obj2 = 0 ;
34335 char * kwnames[] = {
34336 (char *) "self",(char *) "x",(char *) "y", NULL
34337 };
34338
34339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34341 if (!SWIG_IsOK(res1)) {
34342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
34343 }
34344 arg1 = reinterpret_cast< wxWindow * >(argp1);
34345 ecode2 = SWIG_AsVal_int(obj1, &val2);
34346 if (!SWIG_IsOK(ecode2)) {
34347 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
34348 }
34349 arg2 = static_cast< int >(val2);
34350 ecode3 = SWIG_AsVal_int(obj2, &val3);
34351 if (!SWIG_IsOK(ecode3)) {
34352 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
34353 }
34354 arg3 = static_cast< int >(val3);
34355 {
34356 PyThreadState* __tstate = wxPyBeginAllowThreads();
34357 (arg1)->WarpPointer(arg2,arg3);
34358 wxPyEndAllowThreads(__tstate);
34359 if (PyErr_Occurred()) SWIG_fail;
34360 }
34361 resultobj = SWIG_Py_Void();
34362 return resultobj;
34363 fail:
34364 return NULL;
34365 }
34366
34367
34368 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34369 PyObject *resultobj = 0;
34370 wxWindow *arg1 = (wxWindow *) 0 ;
34371 void *argp1 = 0 ;
34372 int res1 = 0 ;
34373 PyObject *swig_obj[1] ;
34374
34375 if (!args) SWIG_fail;
34376 swig_obj[0] = args;
34377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34378 if (!SWIG_IsOK(res1)) {
34379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34380 }
34381 arg1 = reinterpret_cast< wxWindow * >(argp1);
34382 {
34383 PyThreadState* __tstate = wxPyBeginAllowThreads();
34384 (arg1)->CaptureMouse();
34385 wxPyEndAllowThreads(__tstate);
34386 if (PyErr_Occurred()) SWIG_fail;
34387 }
34388 resultobj = SWIG_Py_Void();
34389 return resultobj;
34390 fail:
34391 return NULL;
34392 }
34393
34394
34395 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34396 PyObject *resultobj = 0;
34397 wxWindow *arg1 = (wxWindow *) 0 ;
34398 void *argp1 = 0 ;
34399 int res1 = 0 ;
34400 PyObject *swig_obj[1] ;
34401
34402 if (!args) SWIG_fail;
34403 swig_obj[0] = args;
34404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34405 if (!SWIG_IsOK(res1)) {
34406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34407 }
34408 arg1 = reinterpret_cast< wxWindow * >(argp1);
34409 {
34410 PyThreadState* __tstate = wxPyBeginAllowThreads();
34411 (arg1)->ReleaseMouse();
34412 wxPyEndAllowThreads(__tstate);
34413 if (PyErr_Occurred()) SWIG_fail;
34414 }
34415 resultobj = SWIG_Py_Void();
34416 return resultobj;
34417 fail:
34418 return NULL;
34419 }
34420
34421
34422 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34423 PyObject *resultobj = 0;
34424 wxWindow *result = 0 ;
34425
34426 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
34427 {
34428 if (!wxPyCheckForApp()) SWIG_fail;
34429 PyThreadState* __tstate = wxPyBeginAllowThreads();
34430 result = (wxWindow *)wxWindow::GetCapture();
34431 wxPyEndAllowThreads(__tstate);
34432 if (PyErr_Occurred()) SWIG_fail;
34433 }
34434 {
34435 resultobj = wxPyMake_wxObject(result, 0);
34436 }
34437 return resultobj;
34438 fail:
34439 return NULL;
34440 }
34441
34442
34443 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34444 PyObject *resultobj = 0;
34445 wxWindow *arg1 = (wxWindow *) 0 ;
34446 bool result;
34447 void *argp1 = 0 ;
34448 int res1 = 0 ;
34449 PyObject *swig_obj[1] ;
34450
34451 if (!args) SWIG_fail;
34452 swig_obj[0] = args;
34453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34454 if (!SWIG_IsOK(res1)) {
34455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
34456 }
34457 arg1 = reinterpret_cast< wxWindow * >(argp1);
34458 {
34459 PyThreadState* __tstate = wxPyBeginAllowThreads();
34460 result = (bool)((wxWindow const *)arg1)->HasCapture();
34461 wxPyEndAllowThreads(__tstate);
34462 if (PyErr_Occurred()) SWIG_fail;
34463 }
34464 {
34465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34466 }
34467 return resultobj;
34468 fail:
34469 return NULL;
34470 }
34471
34472
34473 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34474 PyObject *resultobj = 0;
34475 wxWindow *arg1 = (wxWindow *) 0 ;
34476 bool arg2 = (bool) true ;
34477 wxRect *arg3 = (wxRect *) NULL ;
34478 void *argp1 = 0 ;
34479 int res1 = 0 ;
34480 bool val2 ;
34481 int ecode2 = 0 ;
34482 void *argp3 = 0 ;
34483 int res3 = 0 ;
34484 PyObject * obj0 = 0 ;
34485 PyObject * obj1 = 0 ;
34486 PyObject * obj2 = 0 ;
34487 char * kwnames[] = {
34488 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
34489 };
34490
34491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34493 if (!SWIG_IsOK(res1)) {
34494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
34495 }
34496 arg1 = reinterpret_cast< wxWindow * >(argp1);
34497 if (obj1) {
34498 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34499 if (!SWIG_IsOK(ecode2)) {
34500 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
34501 }
34502 arg2 = static_cast< bool >(val2);
34503 }
34504 if (obj2) {
34505 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
34506 if (!SWIG_IsOK(res3)) {
34507 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
34508 }
34509 arg3 = reinterpret_cast< wxRect * >(argp3);
34510 }
34511 {
34512 PyThreadState* __tstate = wxPyBeginAllowThreads();
34513 (arg1)->Refresh(arg2,(wxRect const *)arg3);
34514 wxPyEndAllowThreads(__tstate);
34515 if (PyErr_Occurred()) SWIG_fail;
34516 }
34517 resultobj = SWIG_Py_Void();
34518 return resultobj;
34519 fail:
34520 return NULL;
34521 }
34522
34523
34524 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34525 PyObject *resultobj = 0;
34526 wxWindow *arg1 = (wxWindow *) 0 ;
34527 wxRect *arg2 = 0 ;
34528 bool arg3 = (bool) true ;
34529 void *argp1 = 0 ;
34530 int res1 = 0 ;
34531 wxRect temp2 ;
34532 bool val3 ;
34533 int ecode3 = 0 ;
34534 PyObject * obj0 = 0 ;
34535 PyObject * obj1 = 0 ;
34536 PyObject * obj2 = 0 ;
34537 char * kwnames[] = {
34538 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
34539 };
34540
34541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34543 if (!SWIG_IsOK(res1)) {
34544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34545 }
34546 arg1 = reinterpret_cast< wxWindow * >(argp1);
34547 {
34548 arg2 = &temp2;
34549 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34550 }
34551 if (obj2) {
34552 ecode3 = SWIG_AsVal_bool(obj2, &val3);
34553 if (!SWIG_IsOK(ecode3)) {
34554 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
34555 }
34556 arg3 = static_cast< bool >(val3);
34557 }
34558 {
34559 PyThreadState* __tstate = wxPyBeginAllowThreads();
34560 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
34561 wxPyEndAllowThreads(__tstate);
34562 if (PyErr_Occurred()) SWIG_fail;
34563 }
34564 resultobj = SWIG_Py_Void();
34565 return resultobj;
34566 fail:
34567 return NULL;
34568 }
34569
34570
34571 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34572 PyObject *resultobj = 0;
34573 wxWindow *arg1 = (wxWindow *) 0 ;
34574 void *argp1 = 0 ;
34575 int res1 = 0 ;
34576 PyObject *swig_obj[1] ;
34577
34578 if (!args) SWIG_fail;
34579 swig_obj[0] = args;
34580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34581 if (!SWIG_IsOK(res1)) {
34582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
34583 }
34584 arg1 = reinterpret_cast< wxWindow * >(argp1);
34585 {
34586 PyThreadState* __tstate = wxPyBeginAllowThreads();
34587 (arg1)->Update();
34588 wxPyEndAllowThreads(__tstate);
34589 if (PyErr_Occurred()) SWIG_fail;
34590 }
34591 resultobj = SWIG_Py_Void();
34592 return resultobj;
34593 fail:
34594 return NULL;
34595 }
34596
34597
34598 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34599 PyObject *resultobj = 0;
34600 wxWindow *arg1 = (wxWindow *) 0 ;
34601 void *argp1 = 0 ;
34602 int res1 = 0 ;
34603 PyObject *swig_obj[1] ;
34604
34605 if (!args) SWIG_fail;
34606 swig_obj[0] = args;
34607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34608 if (!SWIG_IsOK(res1)) {
34609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34610 }
34611 arg1 = reinterpret_cast< wxWindow * >(argp1);
34612 {
34613 PyThreadState* __tstate = wxPyBeginAllowThreads();
34614 (arg1)->ClearBackground();
34615 wxPyEndAllowThreads(__tstate);
34616 if (PyErr_Occurred()) SWIG_fail;
34617 }
34618 resultobj = SWIG_Py_Void();
34619 return resultobj;
34620 fail:
34621 return NULL;
34622 }
34623
34624
34625 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34626 PyObject *resultobj = 0;
34627 wxWindow *arg1 = (wxWindow *) 0 ;
34628 void *argp1 = 0 ;
34629 int res1 = 0 ;
34630 PyObject *swig_obj[1] ;
34631
34632 if (!args) SWIG_fail;
34633 swig_obj[0] = args;
34634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34635 if (!SWIG_IsOK(res1)) {
34636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
34637 }
34638 arg1 = reinterpret_cast< wxWindow * >(argp1);
34639 {
34640 PyThreadState* __tstate = wxPyBeginAllowThreads();
34641 (arg1)->Freeze();
34642 wxPyEndAllowThreads(__tstate);
34643 if (PyErr_Occurred()) SWIG_fail;
34644 }
34645 resultobj = SWIG_Py_Void();
34646 return resultobj;
34647 fail:
34648 return NULL;
34649 }
34650
34651
34652 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34653 PyObject *resultobj = 0;
34654 wxWindow *arg1 = (wxWindow *) 0 ;
34655 void *argp1 = 0 ;
34656 int res1 = 0 ;
34657 PyObject *swig_obj[1] ;
34658
34659 if (!args) SWIG_fail;
34660 swig_obj[0] = args;
34661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34662 if (!SWIG_IsOK(res1)) {
34663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
34664 }
34665 arg1 = reinterpret_cast< wxWindow * >(argp1);
34666 {
34667 PyThreadState* __tstate = wxPyBeginAllowThreads();
34668 (arg1)->Thaw();
34669 wxPyEndAllowThreads(__tstate);
34670 if (PyErr_Occurred()) SWIG_fail;
34671 }
34672 resultobj = SWIG_Py_Void();
34673 return resultobj;
34674 fail:
34675 return NULL;
34676 }
34677
34678
34679 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34680 PyObject *resultobj = 0;
34681 wxWindow *arg1 = (wxWindow *) 0 ;
34682 wxDC *arg2 = 0 ;
34683 void *argp1 = 0 ;
34684 int res1 = 0 ;
34685 void *argp2 = 0 ;
34686 int res2 = 0 ;
34687 PyObject * obj0 = 0 ;
34688 PyObject * obj1 = 0 ;
34689 char * kwnames[] = {
34690 (char *) "self",(char *) "dc", NULL
34691 };
34692
34693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
34694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34695 if (!SWIG_IsOK(res1)) {
34696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
34697 }
34698 arg1 = reinterpret_cast< wxWindow * >(argp1);
34699 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
34700 if (!SWIG_IsOK(res2)) {
34701 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34702 }
34703 if (!argp2) {
34704 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34705 }
34706 arg2 = reinterpret_cast< wxDC * >(argp2);
34707 {
34708 PyThreadState* __tstate = wxPyBeginAllowThreads();
34709 (arg1)->PrepareDC(*arg2);
34710 wxPyEndAllowThreads(__tstate);
34711 if (PyErr_Occurred()) SWIG_fail;
34712 }
34713 resultobj = SWIG_Py_Void();
34714 return resultobj;
34715 fail:
34716 return NULL;
34717 }
34718
34719
34720 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34721 PyObject *resultobj = 0;
34722 wxWindow *arg1 = (wxWindow *) 0 ;
34723 wxRegion *result = 0 ;
34724 void *argp1 = 0 ;
34725 int res1 = 0 ;
34726 PyObject *swig_obj[1] ;
34727
34728 if (!args) SWIG_fail;
34729 swig_obj[0] = args;
34730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34731 if (!SWIG_IsOK(res1)) {
34732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
34733 }
34734 arg1 = reinterpret_cast< wxWindow * >(argp1);
34735 {
34736 PyThreadState* __tstate = wxPyBeginAllowThreads();
34737 {
34738 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
34739 result = (wxRegion *) &_result_ref;
34740 }
34741 wxPyEndAllowThreads(__tstate);
34742 if (PyErr_Occurred()) SWIG_fail;
34743 }
34744 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
34745 return resultobj;
34746 fail:
34747 return NULL;
34748 }
34749
34750
34751 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34752 PyObject *resultobj = 0;
34753 wxWindow *arg1 = (wxWindow *) 0 ;
34754 wxRect result;
34755 void *argp1 = 0 ;
34756 int res1 = 0 ;
34757 PyObject *swig_obj[1] ;
34758
34759 if (!args) SWIG_fail;
34760 swig_obj[0] = args;
34761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34762 if (!SWIG_IsOK(res1)) {
34763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34764 }
34765 arg1 = reinterpret_cast< wxWindow * >(argp1);
34766 {
34767 PyThreadState* __tstate = wxPyBeginAllowThreads();
34768 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
34769 wxPyEndAllowThreads(__tstate);
34770 if (PyErr_Occurred()) SWIG_fail;
34771 }
34772 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34773 return resultobj;
34774 fail:
34775 return NULL;
34776 }
34777
34778
34779 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34780 PyObject *resultobj = 0;
34781 wxWindow *arg1 = (wxWindow *) 0 ;
34782 int arg2 ;
34783 int arg3 ;
34784 int arg4 = (int) 1 ;
34785 int arg5 = (int) 1 ;
34786 bool result;
34787 void *argp1 = 0 ;
34788 int res1 = 0 ;
34789 int val2 ;
34790 int ecode2 = 0 ;
34791 int val3 ;
34792 int ecode3 = 0 ;
34793 int val4 ;
34794 int ecode4 = 0 ;
34795 int val5 ;
34796 int ecode5 = 0 ;
34797 PyObject * obj0 = 0 ;
34798 PyObject * obj1 = 0 ;
34799 PyObject * obj2 = 0 ;
34800 PyObject * obj3 = 0 ;
34801 PyObject * obj4 = 0 ;
34802 char * kwnames[] = {
34803 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
34804 };
34805
34806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34808 if (!SWIG_IsOK(res1)) {
34809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
34810 }
34811 arg1 = reinterpret_cast< wxWindow * >(argp1);
34812 ecode2 = SWIG_AsVal_int(obj1, &val2);
34813 if (!SWIG_IsOK(ecode2)) {
34814 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
34815 }
34816 arg2 = static_cast< int >(val2);
34817 ecode3 = SWIG_AsVal_int(obj2, &val3);
34818 if (!SWIG_IsOK(ecode3)) {
34819 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
34820 }
34821 arg3 = static_cast< int >(val3);
34822 if (obj3) {
34823 ecode4 = SWIG_AsVal_int(obj3, &val4);
34824 if (!SWIG_IsOK(ecode4)) {
34825 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
34826 }
34827 arg4 = static_cast< int >(val4);
34828 }
34829 if (obj4) {
34830 ecode5 = SWIG_AsVal_int(obj4, &val5);
34831 if (!SWIG_IsOK(ecode5)) {
34832 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
34833 }
34834 arg5 = static_cast< int >(val5);
34835 }
34836 {
34837 PyThreadState* __tstate = wxPyBeginAllowThreads();
34838 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
34839 wxPyEndAllowThreads(__tstate);
34840 if (PyErr_Occurred()) SWIG_fail;
34841 }
34842 {
34843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34844 }
34845 return resultobj;
34846 fail:
34847 return NULL;
34848 }
34849
34850
34851 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34852 PyObject *resultobj = 0;
34853 wxWindow *arg1 = (wxWindow *) 0 ;
34854 wxPoint *arg2 = 0 ;
34855 bool result;
34856 void *argp1 = 0 ;
34857 int res1 = 0 ;
34858 wxPoint temp2 ;
34859 PyObject * obj0 = 0 ;
34860 PyObject * obj1 = 0 ;
34861 char * kwnames[] = {
34862 (char *) "self",(char *) "pt", NULL
34863 };
34864
34865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
34866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34867 if (!SWIG_IsOK(res1)) {
34868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
34869 }
34870 arg1 = reinterpret_cast< wxWindow * >(argp1);
34871 {
34872 arg2 = &temp2;
34873 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34874 }
34875 {
34876 PyThreadState* __tstate = wxPyBeginAllowThreads();
34877 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
34878 wxPyEndAllowThreads(__tstate);
34879 if (PyErr_Occurred()) SWIG_fail;
34880 }
34881 {
34882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34883 }
34884 return resultobj;
34885 fail:
34886 return NULL;
34887 }
34888
34889
34890 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34891 PyObject *resultobj = 0;
34892 wxWindow *arg1 = (wxWindow *) 0 ;
34893 wxRect *arg2 = 0 ;
34894 bool result;
34895 void *argp1 = 0 ;
34896 int res1 = 0 ;
34897 wxRect temp2 ;
34898 PyObject * obj0 = 0 ;
34899 PyObject * obj1 = 0 ;
34900 char * kwnames[] = {
34901 (char *) "self",(char *) "rect", NULL
34902 };
34903
34904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
34905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34906 if (!SWIG_IsOK(res1)) {
34907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34908 }
34909 arg1 = reinterpret_cast< wxWindow * >(argp1);
34910 {
34911 arg2 = &temp2;
34912 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34913 }
34914 {
34915 PyThreadState* __tstate = wxPyBeginAllowThreads();
34916 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
34917 wxPyEndAllowThreads(__tstate);
34918 if (PyErr_Occurred()) SWIG_fail;
34919 }
34920 {
34921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34922 }
34923 return resultobj;
34924 fail:
34925 return NULL;
34926 }
34927
34928
34929 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34930 PyObject *resultobj = 0;
34931 wxWindow *arg1 = (wxWindow *) 0 ;
34932 SwigValueWrapper<wxVisualAttributes > result;
34933 void *argp1 = 0 ;
34934 int res1 = 0 ;
34935 PyObject *swig_obj[1] ;
34936
34937 if (!args) SWIG_fail;
34938 swig_obj[0] = args;
34939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34940 if (!SWIG_IsOK(res1)) {
34941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
34942 }
34943 arg1 = reinterpret_cast< wxWindow * >(argp1);
34944 {
34945 PyThreadState* __tstate = wxPyBeginAllowThreads();
34946 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
34947 wxPyEndAllowThreads(__tstate);
34948 if (PyErr_Occurred()) SWIG_fail;
34949 }
34950 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34951 return resultobj;
34952 fail:
34953 return NULL;
34954 }
34955
34956
34957 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34958 PyObject *resultobj = 0;
34959 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
34960 SwigValueWrapper<wxVisualAttributes > result;
34961 int val1 ;
34962 int ecode1 = 0 ;
34963 PyObject * obj0 = 0 ;
34964 char * kwnames[] = {
34965 (char *) "variant", NULL
34966 };
34967
34968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
34969 if (obj0) {
34970 ecode1 = SWIG_AsVal_int(obj0, &val1);
34971 if (!SWIG_IsOK(ecode1)) {
34972 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
34973 }
34974 arg1 = static_cast< wxWindowVariant >(val1);
34975 }
34976 {
34977 if (!wxPyCheckForApp()) SWIG_fail;
34978 PyThreadState* __tstate = wxPyBeginAllowThreads();
34979 result = wxWindow::GetClassDefaultAttributes(arg1);
34980 wxPyEndAllowThreads(__tstate);
34981 if (PyErr_Occurred()) SWIG_fail;
34982 }
34983 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34984 return resultobj;
34985 fail:
34986 return NULL;
34987 }
34988
34989
34990 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34991 PyObject *resultobj = 0;
34992 wxWindow *arg1 = (wxWindow *) 0 ;
34993 wxColour *arg2 = 0 ;
34994 bool result;
34995 void *argp1 = 0 ;
34996 int res1 = 0 ;
34997 wxColour temp2 ;
34998 PyObject * obj0 = 0 ;
34999 PyObject * obj1 = 0 ;
35000 char * kwnames[] = {
35001 (char *) "self",(char *) "colour", NULL
35002 };
35003
35004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35006 if (!SWIG_IsOK(res1)) {
35007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35008 }
35009 arg1 = reinterpret_cast< wxWindow * >(argp1);
35010 {
35011 arg2 = &temp2;
35012 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35013 }
35014 {
35015 PyThreadState* __tstate = wxPyBeginAllowThreads();
35016 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
35017 wxPyEndAllowThreads(__tstate);
35018 if (PyErr_Occurred()) SWIG_fail;
35019 }
35020 {
35021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35022 }
35023 return resultobj;
35024 fail:
35025 return NULL;
35026 }
35027
35028
35029 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35030 PyObject *resultobj = 0;
35031 wxWindow *arg1 = (wxWindow *) 0 ;
35032 wxColour *arg2 = 0 ;
35033 void *argp1 = 0 ;
35034 int res1 = 0 ;
35035 wxColour temp2 ;
35036 PyObject * obj0 = 0 ;
35037 PyObject * obj1 = 0 ;
35038 char * kwnames[] = {
35039 (char *) "self",(char *) "colour", NULL
35040 };
35041
35042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35044 if (!SWIG_IsOK(res1)) {
35045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35046 }
35047 arg1 = reinterpret_cast< wxWindow * >(argp1);
35048 {
35049 arg2 = &temp2;
35050 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35051 }
35052 {
35053 PyThreadState* __tstate = wxPyBeginAllowThreads();
35054 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
35055 wxPyEndAllowThreads(__tstate);
35056 if (PyErr_Occurred()) SWIG_fail;
35057 }
35058 resultobj = SWIG_Py_Void();
35059 return resultobj;
35060 fail:
35061 return NULL;
35062 }
35063
35064
35065 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35066 PyObject *resultobj = 0;
35067 wxWindow *arg1 = (wxWindow *) 0 ;
35068 wxColour *arg2 = 0 ;
35069 bool result;
35070 void *argp1 = 0 ;
35071 int res1 = 0 ;
35072 wxColour temp2 ;
35073 PyObject * obj0 = 0 ;
35074 PyObject * obj1 = 0 ;
35075 char * kwnames[] = {
35076 (char *) "self",(char *) "colour", NULL
35077 };
35078
35079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35081 if (!SWIG_IsOK(res1)) {
35082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35083 }
35084 arg1 = reinterpret_cast< wxWindow * >(argp1);
35085 {
35086 arg2 = &temp2;
35087 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35088 }
35089 {
35090 PyThreadState* __tstate = wxPyBeginAllowThreads();
35091 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
35092 wxPyEndAllowThreads(__tstate);
35093 if (PyErr_Occurred()) SWIG_fail;
35094 }
35095 {
35096 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35097 }
35098 return resultobj;
35099 fail:
35100 return NULL;
35101 }
35102
35103
35104 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35105 PyObject *resultobj = 0;
35106 wxWindow *arg1 = (wxWindow *) 0 ;
35107 wxColour *arg2 = 0 ;
35108 void *argp1 = 0 ;
35109 int res1 = 0 ;
35110 wxColour temp2 ;
35111 PyObject * obj0 = 0 ;
35112 PyObject * obj1 = 0 ;
35113 char * kwnames[] = {
35114 (char *) "self",(char *) "colour", NULL
35115 };
35116
35117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35119 if (!SWIG_IsOK(res1)) {
35120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35121 }
35122 arg1 = reinterpret_cast< wxWindow * >(argp1);
35123 {
35124 arg2 = &temp2;
35125 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35126 }
35127 {
35128 PyThreadState* __tstate = wxPyBeginAllowThreads();
35129 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
35130 wxPyEndAllowThreads(__tstate);
35131 if (PyErr_Occurred()) SWIG_fail;
35132 }
35133 resultobj = SWIG_Py_Void();
35134 return resultobj;
35135 fail:
35136 return NULL;
35137 }
35138
35139
35140 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35141 PyObject *resultobj = 0;
35142 wxWindow *arg1 = (wxWindow *) 0 ;
35143 wxColour result;
35144 void *argp1 = 0 ;
35145 int res1 = 0 ;
35146 PyObject *swig_obj[1] ;
35147
35148 if (!args) SWIG_fail;
35149 swig_obj[0] = args;
35150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35151 if (!SWIG_IsOK(res1)) {
35152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35153 }
35154 arg1 = reinterpret_cast< wxWindow * >(argp1);
35155 {
35156 PyThreadState* __tstate = wxPyBeginAllowThreads();
35157 result = ((wxWindow const *)arg1)->GetBackgroundColour();
35158 wxPyEndAllowThreads(__tstate);
35159 if (PyErr_Occurred()) SWIG_fail;
35160 }
35161 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35162 return resultobj;
35163 fail:
35164 return NULL;
35165 }
35166
35167
35168 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35169 PyObject *resultobj = 0;
35170 wxWindow *arg1 = (wxWindow *) 0 ;
35171 wxColour result;
35172 void *argp1 = 0 ;
35173 int res1 = 0 ;
35174 PyObject *swig_obj[1] ;
35175
35176 if (!args) SWIG_fail;
35177 swig_obj[0] = args;
35178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35179 if (!SWIG_IsOK(res1)) {
35180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35181 }
35182 arg1 = reinterpret_cast< wxWindow * >(argp1);
35183 {
35184 PyThreadState* __tstate = wxPyBeginAllowThreads();
35185 result = ((wxWindow const *)arg1)->GetForegroundColour();
35186 wxPyEndAllowThreads(__tstate);
35187 if (PyErr_Occurred()) SWIG_fail;
35188 }
35189 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35190 return resultobj;
35191 fail:
35192 return NULL;
35193 }
35194
35195
35196 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35197 PyObject *resultobj = 0;
35198 wxWindow *arg1 = (wxWindow *) 0 ;
35199 bool result;
35200 void *argp1 = 0 ;
35201 int res1 = 0 ;
35202 PyObject *swig_obj[1] ;
35203
35204 if (!args) SWIG_fail;
35205 swig_obj[0] = args;
35206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35207 if (!SWIG_IsOK(res1)) {
35208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35209 }
35210 arg1 = reinterpret_cast< wxWindow * >(argp1);
35211 {
35212 PyThreadState* __tstate = wxPyBeginAllowThreads();
35213 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
35214 wxPyEndAllowThreads(__tstate);
35215 if (PyErr_Occurred()) SWIG_fail;
35216 }
35217 {
35218 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35219 }
35220 return resultobj;
35221 fail:
35222 return NULL;
35223 }
35224
35225
35226 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35227 PyObject *resultobj = 0;
35228 wxWindow *arg1 = (wxWindow *) 0 ;
35229 bool result;
35230 void *argp1 = 0 ;
35231 int res1 = 0 ;
35232 PyObject *swig_obj[1] ;
35233
35234 if (!args) SWIG_fail;
35235 swig_obj[0] = args;
35236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35237 if (!SWIG_IsOK(res1)) {
35238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
35239 }
35240 arg1 = reinterpret_cast< wxWindow * >(argp1);
35241 {
35242 PyThreadState* __tstate = wxPyBeginAllowThreads();
35243 result = (bool)((wxWindow const *)arg1)->UseBgCol();
35244 wxPyEndAllowThreads(__tstate);
35245 if (PyErr_Occurred()) SWIG_fail;
35246 }
35247 {
35248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35249 }
35250 return resultobj;
35251 fail:
35252 return NULL;
35253 }
35254
35255
35256 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35257 PyObject *resultobj = 0;
35258 wxWindow *arg1 = (wxWindow *) 0 ;
35259 wxBackgroundStyle arg2 ;
35260 bool result;
35261 void *argp1 = 0 ;
35262 int res1 = 0 ;
35263 int val2 ;
35264 int ecode2 = 0 ;
35265 PyObject * obj0 = 0 ;
35266 PyObject * obj1 = 0 ;
35267 char * kwnames[] = {
35268 (char *) "self",(char *) "style", NULL
35269 };
35270
35271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35273 if (!SWIG_IsOK(res1)) {
35274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35275 }
35276 arg1 = reinterpret_cast< wxWindow * >(argp1);
35277 ecode2 = SWIG_AsVal_int(obj1, &val2);
35278 if (!SWIG_IsOK(ecode2)) {
35279 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
35280 }
35281 arg2 = static_cast< wxBackgroundStyle >(val2);
35282 {
35283 PyThreadState* __tstate = wxPyBeginAllowThreads();
35284 result = (bool)(arg1)->SetBackgroundStyle(arg2);
35285 wxPyEndAllowThreads(__tstate);
35286 if (PyErr_Occurred()) SWIG_fail;
35287 }
35288 {
35289 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35290 }
35291 return resultobj;
35292 fail:
35293 return NULL;
35294 }
35295
35296
35297 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35298 PyObject *resultobj = 0;
35299 wxWindow *arg1 = (wxWindow *) 0 ;
35300 wxBackgroundStyle result;
35301 void *argp1 = 0 ;
35302 int res1 = 0 ;
35303 PyObject *swig_obj[1] ;
35304
35305 if (!args) SWIG_fail;
35306 swig_obj[0] = args;
35307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35308 if (!SWIG_IsOK(res1)) {
35309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35310 }
35311 arg1 = reinterpret_cast< wxWindow * >(argp1);
35312 {
35313 PyThreadState* __tstate = wxPyBeginAllowThreads();
35314 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
35315 wxPyEndAllowThreads(__tstate);
35316 if (PyErr_Occurred()) SWIG_fail;
35317 }
35318 resultobj = SWIG_From_int(static_cast< int >(result));
35319 return resultobj;
35320 fail:
35321 return NULL;
35322 }
35323
35324
35325 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35326 PyObject *resultobj = 0;
35327 wxWindow *arg1 = (wxWindow *) 0 ;
35328 bool result;
35329 void *argp1 = 0 ;
35330 int res1 = 0 ;
35331 PyObject *swig_obj[1] ;
35332
35333 if (!args) SWIG_fail;
35334 swig_obj[0] = args;
35335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35336 if (!SWIG_IsOK(res1)) {
35337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35338 }
35339 arg1 = reinterpret_cast< wxWindow * >(argp1);
35340 {
35341 PyThreadState* __tstate = wxPyBeginAllowThreads();
35342 result = (bool)(arg1)->HasTransparentBackground();
35343 wxPyEndAllowThreads(__tstate);
35344 if (PyErr_Occurred()) SWIG_fail;
35345 }
35346 {
35347 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35348 }
35349 return resultobj;
35350 fail:
35351 return NULL;
35352 }
35353
35354
35355 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35356 PyObject *resultobj = 0;
35357 wxWindow *arg1 = (wxWindow *) 0 ;
35358 wxCursor *arg2 = 0 ;
35359 bool result;
35360 void *argp1 = 0 ;
35361 int res1 = 0 ;
35362 void *argp2 = 0 ;
35363 int res2 = 0 ;
35364 PyObject * obj0 = 0 ;
35365 PyObject * obj1 = 0 ;
35366 char * kwnames[] = {
35367 (char *) "self",(char *) "cursor", NULL
35368 };
35369
35370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
35371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35372 if (!SWIG_IsOK(res1)) {
35373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35374 }
35375 arg1 = reinterpret_cast< wxWindow * >(argp1);
35376 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
35377 if (!SWIG_IsOK(res2)) {
35378 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35379 }
35380 if (!argp2) {
35381 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35382 }
35383 arg2 = reinterpret_cast< wxCursor * >(argp2);
35384 {
35385 PyThreadState* __tstate = wxPyBeginAllowThreads();
35386 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
35387 wxPyEndAllowThreads(__tstate);
35388 if (PyErr_Occurred()) SWIG_fail;
35389 }
35390 {
35391 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35392 }
35393 return resultobj;
35394 fail:
35395 return NULL;
35396 }
35397
35398
35399 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35400 PyObject *resultobj = 0;
35401 wxWindow *arg1 = (wxWindow *) 0 ;
35402 wxCursor result;
35403 void *argp1 = 0 ;
35404 int res1 = 0 ;
35405 PyObject *swig_obj[1] ;
35406
35407 if (!args) SWIG_fail;
35408 swig_obj[0] = args;
35409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35410 if (!SWIG_IsOK(res1)) {
35411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35412 }
35413 arg1 = reinterpret_cast< wxWindow * >(argp1);
35414 {
35415 PyThreadState* __tstate = wxPyBeginAllowThreads();
35416 result = (arg1)->GetCursor();
35417 wxPyEndAllowThreads(__tstate);
35418 if (PyErr_Occurred()) SWIG_fail;
35419 }
35420 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
35421 return resultobj;
35422 fail:
35423 return NULL;
35424 }
35425
35426
35427 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35428 PyObject *resultobj = 0;
35429 wxWindow *arg1 = (wxWindow *) 0 ;
35430 wxFont *arg2 = 0 ;
35431 bool result;
35432 void *argp1 = 0 ;
35433 int res1 = 0 ;
35434 void *argp2 = 0 ;
35435 int res2 = 0 ;
35436 PyObject * obj0 = 0 ;
35437 PyObject * obj1 = 0 ;
35438 char * kwnames[] = {
35439 (char *) "self",(char *) "font", NULL
35440 };
35441
35442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
35443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35444 if (!SWIG_IsOK(res1)) {
35445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35446 }
35447 arg1 = reinterpret_cast< wxWindow * >(argp1);
35448 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35449 if (!SWIG_IsOK(res2)) {
35450 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35451 }
35452 if (!argp2) {
35453 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35454 }
35455 arg2 = reinterpret_cast< wxFont * >(argp2);
35456 {
35457 PyThreadState* __tstate = wxPyBeginAllowThreads();
35458 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
35459 wxPyEndAllowThreads(__tstate);
35460 if (PyErr_Occurred()) SWIG_fail;
35461 }
35462 {
35463 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35464 }
35465 return resultobj;
35466 fail:
35467 return NULL;
35468 }
35469
35470
35471 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35472 PyObject *resultobj = 0;
35473 wxWindow *arg1 = (wxWindow *) 0 ;
35474 wxFont *arg2 = 0 ;
35475 void *argp1 = 0 ;
35476 int res1 = 0 ;
35477 void *argp2 = 0 ;
35478 int res2 = 0 ;
35479 PyObject * obj0 = 0 ;
35480 PyObject * obj1 = 0 ;
35481 char * kwnames[] = {
35482 (char *) "self",(char *) "font", NULL
35483 };
35484
35485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
35486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35487 if (!SWIG_IsOK(res1)) {
35488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35489 }
35490 arg1 = reinterpret_cast< wxWindow * >(argp1);
35491 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35492 if (!SWIG_IsOK(res2)) {
35493 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35494 }
35495 if (!argp2) {
35496 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35497 }
35498 arg2 = reinterpret_cast< wxFont * >(argp2);
35499 {
35500 PyThreadState* __tstate = wxPyBeginAllowThreads();
35501 (arg1)->SetOwnFont((wxFont const &)*arg2);
35502 wxPyEndAllowThreads(__tstate);
35503 if (PyErr_Occurred()) SWIG_fail;
35504 }
35505 resultobj = SWIG_Py_Void();
35506 return resultobj;
35507 fail:
35508 return NULL;
35509 }
35510
35511
35512 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35513 PyObject *resultobj = 0;
35514 wxWindow *arg1 = (wxWindow *) 0 ;
35515 wxFont result;
35516 void *argp1 = 0 ;
35517 int res1 = 0 ;
35518 PyObject *swig_obj[1] ;
35519
35520 if (!args) SWIG_fail;
35521 swig_obj[0] = args;
35522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35523 if (!SWIG_IsOK(res1)) {
35524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35525 }
35526 arg1 = reinterpret_cast< wxWindow * >(argp1);
35527 {
35528 PyThreadState* __tstate = wxPyBeginAllowThreads();
35529 result = (arg1)->GetFont();
35530 wxPyEndAllowThreads(__tstate);
35531 if (PyErr_Occurred()) SWIG_fail;
35532 }
35533 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
35534 return resultobj;
35535 fail:
35536 return NULL;
35537 }
35538
35539
35540 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35541 PyObject *resultobj = 0;
35542 wxWindow *arg1 = (wxWindow *) 0 ;
35543 wxCaret *arg2 = (wxCaret *) 0 ;
35544 void *argp1 = 0 ;
35545 int res1 = 0 ;
35546 int res2 = 0 ;
35547 PyObject * obj0 = 0 ;
35548 PyObject * obj1 = 0 ;
35549 char * kwnames[] = {
35550 (char *) "self",(char *) "caret", NULL
35551 };
35552
35553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
35554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35555 if (!SWIG_IsOK(res1)) {
35556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
35557 }
35558 arg1 = reinterpret_cast< wxWindow * >(argp1);
35559 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
35560 if (!SWIG_IsOK(res2)) {
35561 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
35562 }
35563 {
35564 PyThreadState* __tstate = wxPyBeginAllowThreads();
35565 (arg1)->SetCaret(arg2);
35566 wxPyEndAllowThreads(__tstate);
35567 if (PyErr_Occurred()) SWIG_fail;
35568 }
35569 resultobj = SWIG_Py_Void();
35570 return resultobj;
35571 fail:
35572 return NULL;
35573 }
35574
35575
35576 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35577 PyObject *resultobj = 0;
35578 wxWindow *arg1 = (wxWindow *) 0 ;
35579 wxCaret *result = 0 ;
35580 void *argp1 = 0 ;
35581 int res1 = 0 ;
35582 PyObject *swig_obj[1] ;
35583
35584 if (!args) SWIG_fail;
35585 swig_obj[0] = args;
35586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35587 if (!SWIG_IsOK(res1)) {
35588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
35589 }
35590 arg1 = reinterpret_cast< wxWindow * >(argp1);
35591 {
35592 PyThreadState* __tstate = wxPyBeginAllowThreads();
35593 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
35594 wxPyEndAllowThreads(__tstate);
35595 if (PyErr_Occurred()) SWIG_fail;
35596 }
35597 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
35598 return resultobj;
35599 fail:
35600 return NULL;
35601 }
35602
35603
35604 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35605 PyObject *resultobj = 0;
35606 wxWindow *arg1 = (wxWindow *) 0 ;
35607 int result;
35608 void *argp1 = 0 ;
35609 int res1 = 0 ;
35610 PyObject *swig_obj[1] ;
35611
35612 if (!args) SWIG_fail;
35613 swig_obj[0] = args;
35614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35615 if (!SWIG_IsOK(res1)) {
35616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35617 }
35618 arg1 = reinterpret_cast< wxWindow * >(argp1);
35619 {
35620 PyThreadState* __tstate = wxPyBeginAllowThreads();
35621 result = (int)((wxWindow const *)arg1)->GetCharHeight();
35622 wxPyEndAllowThreads(__tstate);
35623 if (PyErr_Occurred()) SWIG_fail;
35624 }
35625 resultobj = SWIG_From_int(static_cast< int >(result));
35626 return resultobj;
35627 fail:
35628 return NULL;
35629 }
35630
35631
35632 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35633 PyObject *resultobj = 0;
35634 wxWindow *arg1 = (wxWindow *) 0 ;
35635 int result;
35636 void *argp1 = 0 ;
35637 int res1 = 0 ;
35638 PyObject *swig_obj[1] ;
35639
35640 if (!args) SWIG_fail;
35641 swig_obj[0] = args;
35642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35643 if (!SWIG_IsOK(res1)) {
35644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35645 }
35646 arg1 = reinterpret_cast< wxWindow * >(argp1);
35647 {
35648 PyThreadState* __tstate = wxPyBeginAllowThreads();
35649 result = (int)((wxWindow const *)arg1)->GetCharWidth();
35650 wxPyEndAllowThreads(__tstate);
35651 if (PyErr_Occurred()) SWIG_fail;
35652 }
35653 resultobj = SWIG_From_int(static_cast< int >(result));
35654 return resultobj;
35655 fail:
35656 return NULL;
35657 }
35658
35659
35660 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35661 PyObject *resultobj = 0;
35662 wxWindow *arg1 = (wxWindow *) 0 ;
35663 wxString *arg2 = 0 ;
35664 int *arg3 = (int *) 0 ;
35665 int *arg4 = (int *) 0 ;
35666 void *argp1 = 0 ;
35667 int res1 = 0 ;
35668 bool temp2 = false ;
35669 int temp3 ;
35670 int res3 = SWIG_TMPOBJ ;
35671 int temp4 ;
35672 int res4 = SWIG_TMPOBJ ;
35673 PyObject * obj0 = 0 ;
35674 PyObject * obj1 = 0 ;
35675 char * kwnames[] = {
35676 (char *) "self",(char *) "string", NULL
35677 };
35678
35679 arg3 = &temp3;
35680 arg4 = &temp4;
35681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
35682 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35683 if (!SWIG_IsOK(res1)) {
35684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35685 }
35686 arg1 = reinterpret_cast< wxWindow * >(argp1);
35687 {
35688 arg2 = wxString_in_helper(obj1);
35689 if (arg2 == NULL) SWIG_fail;
35690 temp2 = true;
35691 }
35692 {
35693 PyThreadState* __tstate = wxPyBeginAllowThreads();
35694 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
35695 wxPyEndAllowThreads(__tstate);
35696 if (PyErr_Occurred()) SWIG_fail;
35697 }
35698 resultobj = SWIG_Py_Void();
35699 if (SWIG_IsTmpObj(res3)) {
35700 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35701 } else {
35702 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35703 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35704 }
35705 if (SWIG_IsTmpObj(res4)) {
35706 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35707 } else {
35708 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35709 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35710 }
35711 {
35712 if (temp2)
35713 delete arg2;
35714 }
35715 return resultobj;
35716 fail:
35717 {
35718 if (temp2)
35719 delete arg2;
35720 }
35721 return NULL;
35722 }
35723
35724
35725 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35726 PyObject *resultobj = 0;
35727 wxWindow *arg1 = (wxWindow *) 0 ;
35728 wxString *arg2 = 0 ;
35729 int *arg3 = (int *) 0 ;
35730 int *arg4 = (int *) 0 ;
35731 int *arg5 = (int *) 0 ;
35732 int *arg6 = (int *) 0 ;
35733 wxFont *arg7 = (wxFont *) NULL ;
35734 void *argp1 = 0 ;
35735 int res1 = 0 ;
35736 bool temp2 = false ;
35737 int temp3 ;
35738 int res3 = SWIG_TMPOBJ ;
35739 int temp4 ;
35740 int res4 = SWIG_TMPOBJ ;
35741 int temp5 ;
35742 int res5 = SWIG_TMPOBJ ;
35743 int temp6 ;
35744 int res6 = SWIG_TMPOBJ ;
35745 void *argp7 = 0 ;
35746 int res7 = 0 ;
35747 PyObject * obj0 = 0 ;
35748 PyObject * obj1 = 0 ;
35749 PyObject * obj2 = 0 ;
35750 char * kwnames[] = {
35751 (char *) "self",(char *) "string",(char *) "font", NULL
35752 };
35753
35754 arg3 = &temp3;
35755 arg4 = &temp4;
35756 arg5 = &temp5;
35757 arg6 = &temp6;
35758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35760 if (!SWIG_IsOK(res1)) {
35761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35762 }
35763 arg1 = reinterpret_cast< wxWindow * >(argp1);
35764 {
35765 arg2 = wxString_in_helper(obj1);
35766 if (arg2 == NULL) SWIG_fail;
35767 temp2 = true;
35768 }
35769 if (obj2) {
35770 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
35771 if (!SWIG_IsOK(res7)) {
35772 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
35773 }
35774 arg7 = reinterpret_cast< wxFont * >(argp7);
35775 }
35776 {
35777 PyThreadState* __tstate = wxPyBeginAllowThreads();
35778 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
35779 wxPyEndAllowThreads(__tstate);
35780 if (PyErr_Occurred()) SWIG_fail;
35781 }
35782 resultobj = SWIG_Py_Void();
35783 if (SWIG_IsTmpObj(res3)) {
35784 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35785 } else {
35786 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35787 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35788 }
35789 if (SWIG_IsTmpObj(res4)) {
35790 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35791 } else {
35792 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35793 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35794 }
35795 if (SWIG_IsTmpObj(res5)) {
35796 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
35797 } else {
35798 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35799 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
35800 }
35801 if (SWIG_IsTmpObj(res6)) {
35802 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
35803 } else {
35804 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35805 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
35806 }
35807 {
35808 if (temp2)
35809 delete arg2;
35810 }
35811 return resultobj;
35812 fail:
35813 {
35814 if (temp2)
35815 delete arg2;
35816 }
35817 return NULL;
35818 }
35819
35820
35821 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35822 PyObject *resultobj = 0;
35823 wxWindow *arg1 = (wxWindow *) 0 ;
35824 int *arg2 = (int *) 0 ;
35825 int *arg3 = (int *) 0 ;
35826 void *argp1 = 0 ;
35827 int res1 = 0 ;
35828 int temp2 ;
35829 int res2 = 0 ;
35830 int temp3 ;
35831 int res3 = 0 ;
35832 PyObject * obj0 = 0 ;
35833 PyObject * obj1 = 0 ;
35834 PyObject * obj2 = 0 ;
35835 char * kwnames[] = {
35836 (char *) "self",(char *) "x",(char *) "y", NULL
35837 };
35838
35839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35841 if (!SWIG_IsOK(res1)) {
35842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35843 }
35844 arg1 = reinterpret_cast< wxWindow * >(argp1);
35845 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35846 int val;
35847 int ecode = SWIG_AsVal_int(obj1, &val);
35848 if (!SWIG_IsOK(ecode)) {
35849 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
35850 }
35851 temp2 = static_cast< int >(val);
35852 arg2 = &temp2;
35853 res2 = SWIG_AddTmpMask(ecode);
35854 }
35855 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35856 int val;
35857 int ecode = SWIG_AsVal_int(obj2, &val);
35858 if (!SWIG_IsOK(ecode)) {
35859 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
35860 }
35861 temp3 = static_cast< int >(val);
35862 arg3 = &temp3;
35863 res3 = SWIG_AddTmpMask(ecode);
35864 }
35865 {
35866 PyThreadState* __tstate = wxPyBeginAllowThreads();
35867 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
35868 wxPyEndAllowThreads(__tstate);
35869 if (PyErr_Occurred()) SWIG_fail;
35870 }
35871 resultobj = SWIG_Py_Void();
35872 if (SWIG_IsTmpObj(res2)) {
35873 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35874 } else {
35875 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35876 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35877 }
35878 if (SWIG_IsTmpObj(res3)) {
35879 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35880 } else {
35881 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35882 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35883 }
35884 return resultobj;
35885 fail:
35886 return NULL;
35887 }
35888
35889
35890 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35891 PyObject *resultobj = 0;
35892 wxWindow *arg1 = (wxWindow *) 0 ;
35893 int *arg2 = (int *) 0 ;
35894 int *arg3 = (int *) 0 ;
35895 void *argp1 = 0 ;
35896 int res1 = 0 ;
35897 int temp2 ;
35898 int res2 = 0 ;
35899 int temp3 ;
35900 int res3 = 0 ;
35901 PyObject * obj0 = 0 ;
35902 PyObject * obj1 = 0 ;
35903 PyObject * obj2 = 0 ;
35904 char * kwnames[] = {
35905 (char *) "self",(char *) "x",(char *) "y", NULL
35906 };
35907
35908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35910 if (!SWIG_IsOK(res1)) {
35911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35912 }
35913 arg1 = reinterpret_cast< wxWindow * >(argp1);
35914 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35915 int val;
35916 int ecode = SWIG_AsVal_int(obj1, &val);
35917 if (!SWIG_IsOK(ecode)) {
35918 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
35919 }
35920 temp2 = static_cast< int >(val);
35921 arg2 = &temp2;
35922 res2 = SWIG_AddTmpMask(ecode);
35923 }
35924 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35925 int val;
35926 int ecode = SWIG_AsVal_int(obj2, &val);
35927 if (!SWIG_IsOK(ecode)) {
35928 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
35929 }
35930 temp3 = static_cast< int >(val);
35931 arg3 = &temp3;
35932 res3 = SWIG_AddTmpMask(ecode);
35933 }
35934 {
35935 PyThreadState* __tstate = wxPyBeginAllowThreads();
35936 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
35937 wxPyEndAllowThreads(__tstate);
35938 if (PyErr_Occurred()) SWIG_fail;
35939 }
35940 resultobj = SWIG_Py_Void();
35941 if (SWIG_IsTmpObj(res2)) {
35942 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35943 } else {
35944 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35945 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35946 }
35947 if (SWIG_IsTmpObj(res3)) {
35948 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35949 } else {
35950 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35951 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35952 }
35953 return resultobj;
35954 fail:
35955 return NULL;
35956 }
35957
35958
35959 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35960 PyObject *resultobj = 0;
35961 wxWindow *arg1 = (wxWindow *) 0 ;
35962 wxPoint *arg2 = 0 ;
35963 wxPoint result;
35964 void *argp1 = 0 ;
35965 int res1 = 0 ;
35966 wxPoint temp2 ;
35967 PyObject * obj0 = 0 ;
35968 PyObject * obj1 = 0 ;
35969 char * kwnames[] = {
35970 (char *) "self",(char *) "pt", NULL
35971 };
35972
35973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
35974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35975 if (!SWIG_IsOK(res1)) {
35976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35977 }
35978 arg1 = reinterpret_cast< wxWindow * >(argp1);
35979 {
35980 arg2 = &temp2;
35981 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35982 }
35983 {
35984 PyThreadState* __tstate = wxPyBeginAllowThreads();
35985 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
35986 wxPyEndAllowThreads(__tstate);
35987 if (PyErr_Occurred()) SWIG_fail;
35988 }
35989 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35990 return resultobj;
35991 fail:
35992 return NULL;
35993 }
35994
35995
35996 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35997 PyObject *resultobj = 0;
35998 wxWindow *arg1 = (wxWindow *) 0 ;
35999 wxPoint *arg2 = 0 ;
36000 wxPoint result;
36001 void *argp1 = 0 ;
36002 int res1 = 0 ;
36003 wxPoint temp2 ;
36004 PyObject * obj0 = 0 ;
36005 PyObject * obj1 = 0 ;
36006 char * kwnames[] = {
36007 (char *) "self",(char *) "pt", NULL
36008 };
36009
36010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
36011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36012 if (!SWIG_IsOK(res1)) {
36013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
36014 }
36015 arg1 = reinterpret_cast< wxWindow * >(argp1);
36016 {
36017 arg2 = &temp2;
36018 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36019 }
36020 {
36021 PyThreadState* __tstate = wxPyBeginAllowThreads();
36022 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
36023 wxPyEndAllowThreads(__tstate);
36024 if (PyErr_Occurred()) SWIG_fail;
36025 }
36026 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
36027 return resultobj;
36028 fail:
36029 return NULL;
36030 }
36031
36032
36033 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36034 PyObject *resultobj = 0;
36035 wxWindow *arg1 = (wxWindow *) 0 ;
36036 int arg2 ;
36037 int arg3 ;
36038 wxHitTest result;
36039 void *argp1 = 0 ;
36040 int res1 = 0 ;
36041 int val2 ;
36042 int ecode2 = 0 ;
36043 int val3 ;
36044 int ecode3 = 0 ;
36045 PyObject * obj0 = 0 ;
36046 PyObject * obj1 = 0 ;
36047 PyObject * obj2 = 0 ;
36048 char * kwnames[] = {
36049 (char *) "self",(char *) "x",(char *) "y", NULL
36050 };
36051
36052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36054 if (!SWIG_IsOK(res1)) {
36055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36056 }
36057 arg1 = reinterpret_cast< wxWindow * >(argp1);
36058 ecode2 = SWIG_AsVal_int(obj1, &val2);
36059 if (!SWIG_IsOK(ecode2)) {
36060 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
36061 }
36062 arg2 = static_cast< int >(val2);
36063 ecode3 = SWIG_AsVal_int(obj2, &val3);
36064 if (!SWIG_IsOK(ecode3)) {
36065 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
36066 }
36067 arg3 = static_cast< int >(val3);
36068 {
36069 PyThreadState* __tstate = wxPyBeginAllowThreads();
36070 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
36071 wxPyEndAllowThreads(__tstate);
36072 if (PyErr_Occurred()) SWIG_fail;
36073 }
36074 resultobj = SWIG_From_int(static_cast< int >(result));
36075 return resultobj;
36076 fail:
36077 return NULL;
36078 }
36079
36080
36081 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36082 PyObject *resultobj = 0;
36083 wxWindow *arg1 = (wxWindow *) 0 ;
36084 wxPoint *arg2 = 0 ;
36085 wxHitTest result;
36086 void *argp1 = 0 ;
36087 int res1 = 0 ;
36088 wxPoint temp2 ;
36089 PyObject * obj0 = 0 ;
36090 PyObject * obj1 = 0 ;
36091 char * kwnames[] = {
36092 (char *) "self",(char *) "pt", NULL
36093 };
36094
36095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
36096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36097 if (!SWIG_IsOK(res1)) {
36098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
36099 }
36100 arg1 = reinterpret_cast< wxWindow * >(argp1);
36101 {
36102 arg2 = &temp2;
36103 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36104 }
36105 {
36106 PyThreadState* __tstate = wxPyBeginAllowThreads();
36107 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
36108 wxPyEndAllowThreads(__tstate);
36109 if (PyErr_Occurred()) SWIG_fail;
36110 }
36111 resultobj = SWIG_From_int(static_cast< int >(result));
36112 return resultobj;
36113 fail:
36114 return NULL;
36115 }
36116
36117
36118 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
36119 PyObject *resultobj = 0;
36120 wxWindow *arg1 = (wxWindow *) 0 ;
36121 long arg2 ;
36122 wxBorder result;
36123 void *argp1 = 0 ;
36124 int res1 = 0 ;
36125 long val2 ;
36126 int ecode2 = 0 ;
36127
36128 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
36129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36130 if (!SWIG_IsOK(res1)) {
36131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
36132 }
36133 arg1 = reinterpret_cast< wxWindow * >(argp1);
36134 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
36135 if (!SWIG_IsOK(ecode2)) {
36136 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
36137 }
36138 arg2 = static_cast< long >(val2);
36139 {
36140 PyThreadState* __tstate = wxPyBeginAllowThreads();
36141 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
36142 wxPyEndAllowThreads(__tstate);
36143 if (PyErr_Occurred()) SWIG_fail;
36144 }
36145 resultobj = SWIG_From_int(static_cast< int >(result));
36146 return resultobj;
36147 fail:
36148 return NULL;
36149 }
36150
36151
36152 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
36153 PyObject *resultobj = 0;
36154 wxWindow *arg1 = (wxWindow *) 0 ;
36155 wxBorder result;
36156 void *argp1 = 0 ;
36157 int res1 = 0 ;
36158
36159 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
36160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36161 if (!SWIG_IsOK(res1)) {
36162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
36163 }
36164 arg1 = reinterpret_cast< wxWindow * >(argp1);
36165 {
36166 PyThreadState* __tstate = wxPyBeginAllowThreads();
36167 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
36168 wxPyEndAllowThreads(__tstate);
36169 if (PyErr_Occurred()) SWIG_fail;
36170 }
36171 resultobj = SWIG_From_int(static_cast< int >(result));
36172 return resultobj;
36173 fail:
36174 return NULL;
36175 }
36176
36177
36178 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
36179 int argc;
36180 PyObject *argv[3];
36181
36182 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
36183 --argc;
36184 if (argc == 1) {
36185 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
36186 }
36187 if (argc == 2) {
36188 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
36189 }
36190
36191 fail:
36192 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
36193 return NULL;
36194 }
36195
36196
36197 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36198 PyObject *resultobj = 0;
36199 wxWindow *arg1 = (wxWindow *) 0 ;
36200 long arg2 = (long) wxUPDATE_UI_NONE ;
36201 void *argp1 = 0 ;
36202 int res1 = 0 ;
36203 long val2 ;
36204 int ecode2 = 0 ;
36205 PyObject * obj0 = 0 ;
36206 PyObject * obj1 = 0 ;
36207 char * kwnames[] = {
36208 (char *) "self",(char *) "flags", NULL
36209 };
36210
36211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
36212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36213 if (!SWIG_IsOK(res1)) {
36214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
36215 }
36216 arg1 = reinterpret_cast< wxWindow * >(argp1);
36217 if (obj1) {
36218 ecode2 = SWIG_AsVal_long(obj1, &val2);
36219 if (!SWIG_IsOK(ecode2)) {
36220 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
36221 }
36222 arg2 = static_cast< long >(val2);
36223 }
36224 {
36225 PyThreadState* __tstate = wxPyBeginAllowThreads();
36226 (arg1)->UpdateWindowUI(arg2);
36227 wxPyEndAllowThreads(__tstate);
36228 if (PyErr_Occurred()) SWIG_fail;
36229 }
36230 resultobj = SWIG_Py_Void();
36231 return resultobj;
36232 fail:
36233 return NULL;
36234 }
36235
36236
36237 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36238 PyObject *resultobj = 0;
36239 wxWindow *arg1 = (wxWindow *) 0 ;
36240 wxMenu *arg2 = (wxMenu *) 0 ;
36241 int arg3 = (int) -1 ;
36242 int arg4 = (int) -1 ;
36243 bool result;
36244 void *argp1 = 0 ;
36245 int res1 = 0 ;
36246 void *argp2 = 0 ;
36247 int res2 = 0 ;
36248 int val3 ;
36249 int ecode3 = 0 ;
36250 int val4 ;
36251 int ecode4 = 0 ;
36252 PyObject * obj0 = 0 ;
36253 PyObject * obj1 = 0 ;
36254 PyObject * obj2 = 0 ;
36255 PyObject * obj3 = 0 ;
36256 char * kwnames[] = {
36257 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
36258 };
36259
36260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36262 if (!SWIG_IsOK(res1)) {
36263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
36264 }
36265 arg1 = reinterpret_cast< wxWindow * >(argp1);
36266 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36267 if (!SWIG_IsOK(res2)) {
36268 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
36269 }
36270 arg2 = reinterpret_cast< wxMenu * >(argp2);
36271 if (obj2) {
36272 ecode3 = SWIG_AsVal_int(obj2, &val3);
36273 if (!SWIG_IsOK(ecode3)) {
36274 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
36275 }
36276 arg3 = static_cast< int >(val3);
36277 }
36278 if (obj3) {
36279 ecode4 = SWIG_AsVal_int(obj3, &val4);
36280 if (!SWIG_IsOK(ecode4)) {
36281 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
36282 }
36283 arg4 = static_cast< int >(val4);
36284 }
36285 {
36286 PyThreadState* __tstate = wxPyBeginAllowThreads();
36287 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
36288 wxPyEndAllowThreads(__tstate);
36289 if (PyErr_Occurred()) SWIG_fail;
36290 }
36291 {
36292 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36293 }
36294 return resultobj;
36295 fail:
36296 return NULL;
36297 }
36298
36299
36300 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36301 PyObject *resultobj = 0;
36302 wxWindow *arg1 = (wxWindow *) 0 ;
36303 wxMenu *arg2 = (wxMenu *) 0 ;
36304 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36305 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36306 bool result;
36307 void *argp1 = 0 ;
36308 int res1 = 0 ;
36309 void *argp2 = 0 ;
36310 int res2 = 0 ;
36311 wxPoint temp3 ;
36312 PyObject * obj0 = 0 ;
36313 PyObject * obj1 = 0 ;
36314 PyObject * obj2 = 0 ;
36315 char * kwnames[] = {
36316 (char *) "self",(char *) "menu",(char *) "pos", NULL
36317 };
36318
36319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36321 if (!SWIG_IsOK(res1)) {
36322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
36323 }
36324 arg1 = reinterpret_cast< wxWindow * >(argp1);
36325 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36326 if (!SWIG_IsOK(res2)) {
36327 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
36328 }
36329 arg2 = reinterpret_cast< wxMenu * >(argp2);
36330 if (obj2) {
36331 {
36332 arg3 = &temp3;
36333 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36334 }
36335 }
36336 {
36337 PyThreadState* __tstate = wxPyBeginAllowThreads();
36338 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
36339 wxPyEndAllowThreads(__tstate);
36340 if (PyErr_Occurred()) SWIG_fail;
36341 }
36342 {
36343 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36344 }
36345 return resultobj;
36346 fail:
36347 return NULL;
36348 }
36349
36350
36351 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36352 PyObject *resultobj = 0;
36353 wxWindow *arg1 = (wxWindow *) 0 ;
36354 bool result;
36355 void *argp1 = 0 ;
36356 int res1 = 0 ;
36357 PyObject *swig_obj[1] ;
36358
36359 if (!args) SWIG_fail;
36360 swig_obj[0] = args;
36361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36362 if (!SWIG_IsOK(res1)) {
36363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
36364 }
36365 arg1 = reinterpret_cast< wxWindow * >(argp1);
36366 {
36367 PyThreadState* __tstate = wxPyBeginAllowThreads();
36368 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
36369 wxPyEndAllowThreads(__tstate);
36370 if (PyErr_Occurred()) SWIG_fail;
36371 }
36372 {
36373 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36374 }
36375 return resultobj;
36376 fail:
36377 return NULL;
36378 }
36379
36380
36381 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36382 PyObject *resultobj = 0;
36383 wxWindow *arg1 = (wxWindow *) 0 ;
36384 long result;
36385 void *argp1 = 0 ;
36386 int res1 = 0 ;
36387 PyObject *swig_obj[1] ;
36388
36389 if (!args) SWIG_fail;
36390 swig_obj[0] = args;
36391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36392 if (!SWIG_IsOK(res1)) {
36393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36394 }
36395 arg1 = reinterpret_cast< wxWindow * >(argp1);
36396 {
36397 PyThreadState* __tstate = wxPyBeginAllowThreads();
36398 result = (long)wxWindow_GetHandle(arg1);
36399 wxPyEndAllowThreads(__tstate);
36400 if (PyErr_Occurred()) SWIG_fail;
36401 }
36402 resultobj = SWIG_From_long(static_cast< long >(result));
36403 return resultobj;
36404 fail:
36405 return NULL;
36406 }
36407
36408
36409 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36410 PyObject *resultobj = 0;
36411 wxWindow *arg1 = (wxWindow *) 0 ;
36412 long arg2 ;
36413 void *argp1 = 0 ;
36414 int res1 = 0 ;
36415 long val2 ;
36416 int ecode2 = 0 ;
36417 PyObject * obj0 = 0 ;
36418 PyObject * obj1 = 0 ;
36419 char * kwnames[] = {
36420 (char *) "self",(char *) "handle", NULL
36421 };
36422
36423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
36424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36425 if (!SWIG_IsOK(res1)) {
36426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36427 }
36428 arg1 = reinterpret_cast< wxWindow * >(argp1);
36429 ecode2 = SWIG_AsVal_long(obj1, &val2);
36430 if (!SWIG_IsOK(ecode2)) {
36431 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
36432 }
36433 arg2 = static_cast< long >(val2);
36434 {
36435 PyThreadState* __tstate = wxPyBeginAllowThreads();
36436 wxWindow_AssociateHandle(arg1,arg2);
36437 wxPyEndAllowThreads(__tstate);
36438 if (PyErr_Occurred()) SWIG_fail;
36439 }
36440 resultobj = SWIG_Py_Void();
36441 return resultobj;
36442 fail:
36443 return NULL;
36444 }
36445
36446
36447 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36448 PyObject *resultobj = 0;
36449 wxWindow *arg1 = (wxWindow *) 0 ;
36450 void *argp1 = 0 ;
36451 int res1 = 0 ;
36452 PyObject *swig_obj[1] ;
36453
36454 if (!args) SWIG_fail;
36455 swig_obj[0] = args;
36456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36457 if (!SWIG_IsOK(res1)) {
36458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36459 }
36460 arg1 = reinterpret_cast< wxWindow * >(argp1);
36461 {
36462 PyThreadState* __tstate = wxPyBeginAllowThreads();
36463 (arg1)->DissociateHandle();
36464 wxPyEndAllowThreads(__tstate);
36465 if (PyErr_Occurred()) SWIG_fail;
36466 }
36467 resultobj = SWIG_Py_Void();
36468 return resultobj;
36469 fail:
36470 return NULL;
36471 }
36472
36473
36474 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36475 PyObject *resultobj = 0;
36476 wxWindow *arg1 = (wxWindow *) 0 ;
36477 int arg2 ;
36478 bool result;
36479 void *argp1 = 0 ;
36480 int res1 = 0 ;
36481 int val2 ;
36482 int ecode2 = 0 ;
36483 PyObject * obj0 = 0 ;
36484 PyObject * obj1 = 0 ;
36485 char * kwnames[] = {
36486 (char *) "self",(char *) "orient", NULL
36487 };
36488
36489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
36490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36491 if (!SWIG_IsOK(res1)) {
36492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
36493 }
36494 arg1 = reinterpret_cast< wxWindow * >(argp1);
36495 ecode2 = SWIG_AsVal_int(obj1, &val2);
36496 if (!SWIG_IsOK(ecode2)) {
36497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
36498 }
36499 arg2 = static_cast< int >(val2);
36500 {
36501 PyThreadState* __tstate = wxPyBeginAllowThreads();
36502 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
36503 wxPyEndAllowThreads(__tstate);
36504 if (PyErr_Occurred()) SWIG_fail;
36505 }
36506 {
36507 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36508 }
36509 return resultobj;
36510 fail:
36511 return NULL;
36512 }
36513
36514
36515 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36516 PyObject *resultobj = 0;
36517 wxWindow *arg1 = (wxWindow *) 0 ;
36518 int arg2 ;
36519 int arg3 ;
36520 int arg4 ;
36521 int arg5 ;
36522 bool arg6 = (bool) true ;
36523 void *argp1 = 0 ;
36524 int res1 = 0 ;
36525 int val2 ;
36526 int ecode2 = 0 ;
36527 int val3 ;
36528 int ecode3 = 0 ;
36529 int val4 ;
36530 int ecode4 = 0 ;
36531 int val5 ;
36532 int ecode5 = 0 ;
36533 bool val6 ;
36534 int ecode6 = 0 ;
36535 PyObject * obj0 = 0 ;
36536 PyObject * obj1 = 0 ;
36537 PyObject * obj2 = 0 ;
36538 PyObject * obj3 = 0 ;
36539 PyObject * obj4 = 0 ;
36540 PyObject * obj5 = 0 ;
36541 char * kwnames[] = {
36542 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
36543 };
36544
36545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
36546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36547 if (!SWIG_IsOK(res1)) {
36548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
36549 }
36550 arg1 = reinterpret_cast< wxWindow * >(argp1);
36551 ecode2 = SWIG_AsVal_int(obj1, &val2);
36552 if (!SWIG_IsOK(ecode2)) {
36553 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
36554 }
36555 arg2 = static_cast< int >(val2);
36556 ecode3 = SWIG_AsVal_int(obj2, &val3);
36557 if (!SWIG_IsOK(ecode3)) {
36558 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
36559 }
36560 arg3 = static_cast< int >(val3);
36561 ecode4 = SWIG_AsVal_int(obj3, &val4);
36562 if (!SWIG_IsOK(ecode4)) {
36563 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
36564 }
36565 arg4 = static_cast< int >(val4);
36566 ecode5 = SWIG_AsVal_int(obj4, &val5);
36567 if (!SWIG_IsOK(ecode5)) {
36568 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
36569 }
36570 arg5 = static_cast< int >(val5);
36571 if (obj5) {
36572 ecode6 = SWIG_AsVal_bool(obj5, &val6);
36573 if (!SWIG_IsOK(ecode6)) {
36574 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
36575 }
36576 arg6 = static_cast< bool >(val6);
36577 }
36578 {
36579 PyThreadState* __tstate = wxPyBeginAllowThreads();
36580 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
36581 wxPyEndAllowThreads(__tstate);
36582 if (PyErr_Occurred()) SWIG_fail;
36583 }
36584 resultobj = SWIG_Py_Void();
36585 return resultobj;
36586 fail:
36587 return NULL;
36588 }
36589
36590
36591 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36592 PyObject *resultobj = 0;
36593 wxWindow *arg1 = (wxWindow *) 0 ;
36594 int arg2 ;
36595 int arg3 ;
36596 bool arg4 = (bool) true ;
36597 void *argp1 = 0 ;
36598 int res1 = 0 ;
36599 int val2 ;
36600 int ecode2 = 0 ;
36601 int val3 ;
36602 int ecode3 = 0 ;
36603 bool val4 ;
36604 int ecode4 = 0 ;
36605 PyObject * obj0 = 0 ;
36606 PyObject * obj1 = 0 ;
36607 PyObject * obj2 = 0 ;
36608 PyObject * obj3 = 0 ;
36609 char * kwnames[] = {
36610 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
36611 };
36612
36613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36615 if (!SWIG_IsOK(res1)) {
36616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
36617 }
36618 arg1 = reinterpret_cast< wxWindow * >(argp1);
36619 ecode2 = SWIG_AsVal_int(obj1, &val2);
36620 if (!SWIG_IsOK(ecode2)) {
36621 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
36622 }
36623 arg2 = static_cast< int >(val2);
36624 ecode3 = SWIG_AsVal_int(obj2, &val3);
36625 if (!SWIG_IsOK(ecode3)) {
36626 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
36627 }
36628 arg3 = static_cast< int >(val3);
36629 if (obj3) {
36630 ecode4 = SWIG_AsVal_bool(obj3, &val4);
36631 if (!SWIG_IsOK(ecode4)) {
36632 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
36633 }
36634 arg4 = static_cast< bool >(val4);
36635 }
36636 {
36637 PyThreadState* __tstate = wxPyBeginAllowThreads();
36638 (arg1)->SetScrollPos(arg2,arg3,arg4);
36639 wxPyEndAllowThreads(__tstate);
36640 if (PyErr_Occurred()) SWIG_fail;
36641 }
36642 resultobj = SWIG_Py_Void();
36643 return resultobj;
36644 fail:
36645 return NULL;
36646 }
36647
36648
36649 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36650 PyObject *resultobj = 0;
36651 wxWindow *arg1 = (wxWindow *) 0 ;
36652 int arg2 ;
36653 int result;
36654 void *argp1 = 0 ;
36655 int res1 = 0 ;
36656 int val2 ;
36657 int ecode2 = 0 ;
36658 PyObject * obj0 = 0 ;
36659 PyObject * obj1 = 0 ;
36660 char * kwnames[] = {
36661 (char *) "self",(char *) "orientation", NULL
36662 };
36663
36664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
36665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36666 if (!SWIG_IsOK(res1)) {
36667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
36668 }
36669 arg1 = reinterpret_cast< wxWindow * >(argp1);
36670 ecode2 = SWIG_AsVal_int(obj1, &val2);
36671 if (!SWIG_IsOK(ecode2)) {
36672 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
36673 }
36674 arg2 = static_cast< int >(val2);
36675 {
36676 PyThreadState* __tstate = wxPyBeginAllowThreads();
36677 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
36678 wxPyEndAllowThreads(__tstate);
36679 if (PyErr_Occurred()) SWIG_fail;
36680 }
36681 resultobj = SWIG_From_int(static_cast< int >(result));
36682 return resultobj;
36683 fail:
36684 return NULL;
36685 }
36686
36687
36688 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36689 PyObject *resultobj = 0;
36690 wxWindow *arg1 = (wxWindow *) 0 ;
36691 int arg2 ;
36692 int result;
36693 void *argp1 = 0 ;
36694 int res1 = 0 ;
36695 int val2 ;
36696 int ecode2 = 0 ;
36697 PyObject * obj0 = 0 ;
36698 PyObject * obj1 = 0 ;
36699 char * kwnames[] = {
36700 (char *) "self",(char *) "orientation", NULL
36701 };
36702
36703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
36704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36705 if (!SWIG_IsOK(res1)) {
36706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
36707 }
36708 arg1 = reinterpret_cast< wxWindow * >(argp1);
36709 ecode2 = SWIG_AsVal_int(obj1, &val2);
36710 if (!SWIG_IsOK(ecode2)) {
36711 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
36712 }
36713 arg2 = static_cast< int >(val2);
36714 {
36715 PyThreadState* __tstate = wxPyBeginAllowThreads();
36716 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
36717 wxPyEndAllowThreads(__tstate);
36718 if (PyErr_Occurred()) SWIG_fail;
36719 }
36720 resultobj = SWIG_From_int(static_cast< int >(result));
36721 return resultobj;
36722 fail:
36723 return NULL;
36724 }
36725
36726
36727 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36728 PyObject *resultobj = 0;
36729 wxWindow *arg1 = (wxWindow *) 0 ;
36730 int arg2 ;
36731 int result;
36732 void *argp1 = 0 ;
36733 int res1 = 0 ;
36734 int val2 ;
36735 int ecode2 = 0 ;
36736 PyObject * obj0 = 0 ;
36737 PyObject * obj1 = 0 ;
36738 char * kwnames[] = {
36739 (char *) "self",(char *) "orientation", NULL
36740 };
36741
36742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
36743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36744 if (!SWIG_IsOK(res1)) {
36745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
36746 }
36747 arg1 = reinterpret_cast< wxWindow * >(argp1);
36748 ecode2 = SWIG_AsVal_int(obj1, &val2);
36749 if (!SWIG_IsOK(ecode2)) {
36750 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
36751 }
36752 arg2 = static_cast< int >(val2);
36753 {
36754 PyThreadState* __tstate = wxPyBeginAllowThreads();
36755 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
36756 wxPyEndAllowThreads(__tstate);
36757 if (PyErr_Occurred()) SWIG_fail;
36758 }
36759 resultobj = SWIG_From_int(static_cast< int >(result));
36760 return resultobj;
36761 fail:
36762 return NULL;
36763 }
36764
36765
36766 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36767 PyObject *resultobj = 0;
36768 wxWindow *arg1 = (wxWindow *) 0 ;
36769 int arg2 ;
36770 int arg3 ;
36771 wxRect *arg4 = (wxRect *) NULL ;
36772 void *argp1 = 0 ;
36773 int res1 = 0 ;
36774 int val2 ;
36775 int ecode2 = 0 ;
36776 int val3 ;
36777 int ecode3 = 0 ;
36778 void *argp4 = 0 ;
36779 int res4 = 0 ;
36780 PyObject * obj0 = 0 ;
36781 PyObject * obj1 = 0 ;
36782 PyObject * obj2 = 0 ;
36783 PyObject * obj3 = 0 ;
36784 char * kwnames[] = {
36785 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
36786 };
36787
36788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36790 if (!SWIG_IsOK(res1)) {
36791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36792 }
36793 arg1 = reinterpret_cast< wxWindow * >(argp1);
36794 ecode2 = SWIG_AsVal_int(obj1, &val2);
36795 if (!SWIG_IsOK(ecode2)) {
36796 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
36797 }
36798 arg2 = static_cast< int >(val2);
36799 ecode3 = SWIG_AsVal_int(obj2, &val3);
36800 if (!SWIG_IsOK(ecode3)) {
36801 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
36802 }
36803 arg3 = static_cast< int >(val3);
36804 if (obj3) {
36805 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
36806 if (!SWIG_IsOK(res4)) {
36807 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
36808 }
36809 arg4 = reinterpret_cast< wxRect * >(argp4);
36810 }
36811 {
36812 PyThreadState* __tstate = wxPyBeginAllowThreads();
36813 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
36814 wxPyEndAllowThreads(__tstate);
36815 if (PyErr_Occurred()) SWIG_fail;
36816 }
36817 resultobj = SWIG_Py_Void();
36818 return resultobj;
36819 fail:
36820 return NULL;
36821 }
36822
36823
36824 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36825 PyObject *resultobj = 0;
36826 wxWindow *arg1 = (wxWindow *) 0 ;
36827 int arg2 ;
36828 bool result;
36829 void *argp1 = 0 ;
36830 int res1 = 0 ;
36831 int val2 ;
36832 int ecode2 = 0 ;
36833 PyObject * obj0 = 0 ;
36834 PyObject * obj1 = 0 ;
36835 char * kwnames[] = {
36836 (char *) "self",(char *) "lines", NULL
36837 };
36838
36839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
36840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36841 if (!SWIG_IsOK(res1)) {
36842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
36843 }
36844 arg1 = reinterpret_cast< wxWindow * >(argp1);
36845 ecode2 = SWIG_AsVal_int(obj1, &val2);
36846 if (!SWIG_IsOK(ecode2)) {
36847 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
36848 }
36849 arg2 = static_cast< int >(val2);
36850 {
36851 PyThreadState* __tstate = wxPyBeginAllowThreads();
36852 result = (bool)(arg1)->ScrollLines(arg2);
36853 wxPyEndAllowThreads(__tstate);
36854 if (PyErr_Occurred()) SWIG_fail;
36855 }
36856 {
36857 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36858 }
36859 return resultobj;
36860 fail:
36861 return NULL;
36862 }
36863
36864
36865 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36866 PyObject *resultobj = 0;
36867 wxWindow *arg1 = (wxWindow *) 0 ;
36868 int arg2 ;
36869 bool result;
36870 void *argp1 = 0 ;
36871 int res1 = 0 ;
36872 int val2 ;
36873 int ecode2 = 0 ;
36874 PyObject * obj0 = 0 ;
36875 PyObject * obj1 = 0 ;
36876 char * kwnames[] = {
36877 (char *) "self",(char *) "pages", NULL
36878 };
36879
36880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
36881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36882 if (!SWIG_IsOK(res1)) {
36883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
36884 }
36885 arg1 = reinterpret_cast< wxWindow * >(argp1);
36886 ecode2 = SWIG_AsVal_int(obj1, &val2);
36887 if (!SWIG_IsOK(ecode2)) {
36888 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
36889 }
36890 arg2 = static_cast< int >(val2);
36891 {
36892 PyThreadState* __tstate = wxPyBeginAllowThreads();
36893 result = (bool)(arg1)->ScrollPages(arg2);
36894 wxPyEndAllowThreads(__tstate);
36895 if (PyErr_Occurred()) SWIG_fail;
36896 }
36897 {
36898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36899 }
36900 return resultobj;
36901 fail:
36902 return NULL;
36903 }
36904
36905
36906 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36907 PyObject *resultobj = 0;
36908 wxWindow *arg1 = (wxWindow *) 0 ;
36909 bool result;
36910 void *argp1 = 0 ;
36911 int res1 = 0 ;
36912 PyObject *swig_obj[1] ;
36913
36914 if (!args) SWIG_fail;
36915 swig_obj[0] = args;
36916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36917 if (!SWIG_IsOK(res1)) {
36918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36919 }
36920 arg1 = reinterpret_cast< wxWindow * >(argp1);
36921 {
36922 PyThreadState* __tstate = wxPyBeginAllowThreads();
36923 result = (bool)(arg1)->LineUp();
36924 wxPyEndAllowThreads(__tstate);
36925 if (PyErr_Occurred()) SWIG_fail;
36926 }
36927 {
36928 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36929 }
36930 return resultobj;
36931 fail:
36932 return NULL;
36933 }
36934
36935
36936 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36937 PyObject *resultobj = 0;
36938 wxWindow *arg1 = (wxWindow *) 0 ;
36939 bool result;
36940 void *argp1 = 0 ;
36941 int res1 = 0 ;
36942 PyObject *swig_obj[1] ;
36943
36944 if (!args) SWIG_fail;
36945 swig_obj[0] = args;
36946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36947 if (!SWIG_IsOK(res1)) {
36948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36949 }
36950 arg1 = reinterpret_cast< wxWindow * >(argp1);
36951 {
36952 PyThreadState* __tstate = wxPyBeginAllowThreads();
36953 result = (bool)(arg1)->LineDown();
36954 wxPyEndAllowThreads(__tstate);
36955 if (PyErr_Occurred()) SWIG_fail;
36956 }
36957 {
36958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36959 }
36960 return resultobj;
36961 fail:
36962 return NULL;
36963 }
36964
36965
36966 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36967 PyObject *resultobj = 0;
36968 wxWindow *arg1 = (wxWindow *) 0 ;
36969 bool result;
36970 void *argp1 = 0 ;
36971 int res1 = 0 ;
36972 PyObject *swig_obj[1] ;
36973
36974 if (!args) SWIG_fail;
36975 swig_obj[0] = args;
36976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36977 if (!SWIG_IsOK(res1)) {
36978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36979 }
36980 arg1 = reinterpret_cast< wxWindow * >(argp1);
36981 {
36982 PyThreadState* __tstate = wxPyBeginAllowThreads();
36983 result = (bool)(arg1)->PageUp();
36984 wxPyEndAllowThreads(__tstate);
36985 if (PyErr_Occurred()) SWIG_fail;
36986 }
36987 {
36988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36989 }
36990 return resultobj;
36991 fail:
36992 return NULL;
36993 }
36994
36995
36996 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36997 PyObject *resultobj = 0;
36998 wxWindow *arg1 = (wxWindow *) 0 ;
36999 bool result;
37000 void *argp1 = 0 ;
37001 int res1 = 0 ;
37002 PyObject *swig_obj[1] ;
37003
37004 if (!args) SWIG_fail;
37005 swig_obj[0] = args;
37006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37007 if (!SWIG_IsOK(res1)) {
37008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
37009 }
37010 arg1 = reinterpret_cast< wxWindow * >(argp1);
37011 {
37012 PyThreadState* __tstate = wxPyBeginAllowThreads();
37013 result = (bool)(arg1)->PageDown();
37014 wxPyEndAllowThreads(__tstate);
37015 if (PyErr_Occurred()) SWIG_fail;
37016 }
37017 {
37018 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37019 }
37020 return resultobj;
37021 fail:
37022 return NULL;
37023 }
37024
37025
37026 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37027 PyObject *resultobj = 0;
37028 wxWindow *arg1 = (wxWindow *) 0 ;
37029 wxString *arg2 = 0 ;
37030 void *argp1 = 0 ;
37031 int res1 = 0 ;
37032 bool temp2 = false ;
37033 PyObject * obj0 = 0 ;
37034 PyObject * obj1 = 0 ;
37035 char * kwnames[] = {
37036 (char *) "self",(char *) "text", NULL
37037 };
37038
37039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
37040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37041 if (!SWIG_IsOK(res1)) {
37042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
37043 }
37044 arg1 = reinterpret_cast< wxWindow * >(argp1);
37045 {
37046 arg2 = wxString_in_helper(obj1);
37047 if (arg2 == NULL) SWIG_fail;
37048 temp2 = true;
37049 }
37050 {
37051 PyThreadState* __tstate = wxPyBeginAllowThreads();
37052 (arg1)->SetHelpText((wxString const &)*arg2);
37053 wxPyEndAllowThreads(__tstate);
37054 if (PyErr_Occurred()) SWIG_fail;
37055 }
37056 resultobj = SWIG_Py_Void();
37057 {
37058 if (temp2)
37059 delete arg2;
37060 }
37061 return resultobj;
37062 fail:
37063 {
37064 if (temp2)
37065 delete arg2;
37066 }
37067 return NULL;
37068 }
37069
37070
37071 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37072 PyObject *resultobj = 0;
37073 wxWindow *arg1 = (wxWindow *) 0 ;
37074 wxString *arg2 = 0 ;
37075 void *argp1 = 0 ;
37076 int res1 = 0 ;
37077 bool temp2 = false ;
37078 PyObject * obj0 = 0 ;
37079 PyObject * obj1 = 0 ;
37080 char * kwnames[] = {
37081 (char *) "self",(char *) "text", NULL
37082 };
37083
37084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
37085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37086 if (!SWIG_IsOK(res1)) {
37087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
37088 }
37089 arg1 = reinterpret_cast< wxWindow * >(argp1);
37090 {
37091 arg2 = wxString_in_helper(obj1);
37092 if (arg2 == NULL) SWIG_fail;
37093 temp2 = true;
37094 }
37095 {
37096 PyThreadState* __tstate = wxPyBeginAllowThreads();
37097 (arg1)->SetHelpTextForId((wxString const &)*arg2);
37098 wxPyEndAllowThreads(__tstate);
37099 if (PyErr_Occurred()) SWIG_fail;
37100 }
37101 resultobj = SWIG_Py_Void();
37102 {
37103 if (temp2)
37104 delete arg2;
37105 }
37106 return resultobj;
37107 fail:
37108 {
37109 if (temp2)
37110 delete arg2;
37111 }
37112 return NULL;
37113 }
37114
37115
37116 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37117 PyObject *resultobj = 0;
37118 wxWindow *arg1 = (wxWindow *) 0 ;
37119 wxPoint *arg2 = 0 ;
37120 wxHelpEvent::Origin arg3 ;
37121 wxString result;
37122 void *argp1 = 0 ;
37123 int res1 = 0 ;
37124 wxPoint temp2 ;
37125 void *argp3 ;
37126 int res3 = 0 ;
37127 PyObject * obj0 = 0 ;
37128 PyObject * obj1 = 0 ;
37129 PyObject * obj2 = 0 ;
37130 char * kwnames[] = {
37131 (char *) "self",(char *) "pt",(char *) "origin", NULL
37132 };
37133
37134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37136 if (!SWIG_IsOK(res1)) {
37137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
37138 }
37139 arg1 = reinterpret_cast< wxWindow * >(argp1);
37140 {
37141 arg2 = &temp2;
37142 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37143 }
37144 {
37145 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
37146 if (!SWIG_IsOK(res3)) {
37147 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
37148 }
37149 if (!argp3) {
37150 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
37151 } else {
37152 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
37153 arg3 = *temp;
37154 if (SWIG_IsNewObj(res3)) delete temp;
37155 }
37156 }
37157 {
37158 PyThreadState* __tstate = wxPyBeginAllowThreads();
37159 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
37160 wxPyEndAllowThreads(__tstate);
37161 if (PyErr_Occurred()) SWIG_fail;
37162 }
37163 {
37164 #if wxUSE_UNICODE
37165 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37166 #else
37167 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37168 #endif
37169 }
37170 return resultobj;
37171 fail:
37172 return NULL;
37173 }
37174
37175
37176 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37177 PyObject *resultobj = 0;
37178 wxWindow *arg1 = (wxWindow *) 0 ;
37179 wxString result;
37180 void *argp1 = 0 ;
37181 int res1 = 0 ;
37182 PyObject *swig_obj[1] ;
37183
37184 if (!args) SWIG_fail;
37185 swig_obj[0] = args;
37186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37187 if (!SWIG_IsOK(res1)) {
37188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
37189 }
37190 arg1 = reinterpret_cast< wxWindow * >(argp1);
37191 {
37192 PyThreadState* __tstate = wxPyBeginAllowThreads();
37193 result = ((wxWindow const *)arg1)->GetHelpText();
37194 wxPyEndAllowThreads(__tstate);
37195 if (PyErr_Occurred()) SWIG_fail;
37196 }
37197 {
37198 #if wxUSE_UNICODE
37199 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37200 #else
37201 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37202 #endif
37203 }
37204 return resultobj;
37205 fail:
37206 return NULL;
37207 }
37208
37209
37210 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37211 PyObject *resultobj = 0;
37212 wxWindow *arg1 = (wxWindow *) 0 ;
37213 wxString *arg2 = 0 ;
37214 void *argp1 = 0 ;
37215 int res1 = 0 ;
37216 bool temp2 = false ;
37217 PyObject * obj0 = 0 ;
37218 PyObject * obj1 = 0 ;
37219 char * kwnames[] = {
37220 (char *) "self",(char *) "tip", NULL
37221 };
37222
37223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
37224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37225 if (!SWIG_IsOK(res1)) {
37226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
37227 }
37228 arg1 = reinterpret_cast< wxWindow * >(argp1);
37229 {
37230 arg2 = wxString_in_helper(obj1);
37231 if (arg2 == NULL) SWIG_fail;
37232 temp2 = true;
37233 }
37234 {
37235 PyThreadState* __tstate = wxPyBeginAllowThreads();
37236 (arg1)->SetToolTip((wxString const &)*arg2);
37237 wxPyEndAllowThreads(__tstate);
37238 if (PyErr_Occurred()) SWIG_fail;
37239 }
37240 resultobj = SWIG_Py_Void();
37241 {
37242 if (temp2)
37243 delete arg2;
37244 }
37245 return resultobj;
37246 fail:
37247 {
37248 if (temp2)
37249 delete arg2;
37250 }
37251 return NULL;
37252 }
37253
37254
37255 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37256 PyObject *resultobj = 0;
37257 wxWindow *arg1 = (wxWindow *) 0 ;
37258 wxToolTip *arg2 = (wxToolTip *) 0 ;
37259 void *argp1 = 0 ;
37260 int res1 = 0 ;
37261 int res2 = 0 ;
37262 PyObject * obj0 = 0 ;
37263 PyObject * obj1 = 0 ;
37264 char * kwnames[] = {
37265 (char *) "self",(char *) "tip", NULL
37266 };
37267
37268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
37269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37270 if (!SWIG_IsOK(res1)) {
37271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
37272 }
37273 arg1 = reinterpret_cast< wxWindow * >(argp1);
37274 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
37275 if (!SWIG_IsOK(res2)) {
37276 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
37277 }
37278 {
37279 PyThreadState* __tstate = wxPyBeginAllowThreads();
37280 (arg1)->SetToolTip(arg2);
37281 wxPyEndAllowThreads(__tstate);
37282 if (PyErr_Occurred()) SWIG_fail;
37283 }
37284 resultobj = SWIG_Py_Void();
37285 return resultobj;
37286 fail:
37287 return NULL;
37288 }
37289
37290
37291 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37292 PyObject *resultobj = 0;
37293 wxWindow *arg1 = (wxWindow *) 0 ;
37294 wxToolTip *result = 0 ;
37295 void *argp1 = 0 ;
37296 int res1 = 0 ;
37297 PyObject *swig_obj[1] ;
37298
37299 if (!args) SWIG_fail;
37300 swig_obj[0] = args;
37301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37302 if (!SWIG_IsOK(res1)) {
37303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
37304 }
37305 arg1 = reinterpret_cast< wxWindow * >(argp1);
37306 {
37307 PyThreadState* __tstate = wxPyBeginAllowThreads();
37308 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
37309 wxPyEndAllowThreads(__tstate);
37310 if (PyErr_Occurred()) SWIG_fail;
37311 }
37312 {
37313 resultobj = wxPyMake_wxObject(result, (bool)0);
37314 }
37315 return resultobj;
37316 fail:
37317 return NULL;
37318 }
37319
37320
37321 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37322 PyObject *resultobj = 0;
37323 wxWindow *arg1 = (wxWindow *) 0 ;
37324 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
37325 void *argp1 = 0 ;
37326 int res1 = 0 ;
37327 int res2 = 0 ;
37328 PyObject * obj0 = 0 ;
37329 PyObject * obj1 = 0 ;
37330 char * kwnames[] = {
37331 (char *) "self",(char *) "dropTarget", NULL
37332 };
37333
37334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
37335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37336 if (!SWIG_IsOK(res1)) {
37337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
37338 }
37339 arg1 = reinterpret_cast< wxWindow * >(argp1);
37340 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
37341 if (!SWIG_IsOK(res2)) {
37342 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
37343 }
37344 {
37345 PyThreadState* __tstate = wxPyBeginAllowThreads();
37346 (arg1)->SetDropTarget(arg2);
37347 wxPyEndAllowThreads(__tstate);
37348 if (PyErr_Occurred()) SWIG_fail;
37349 }
37350 resultobj = SWIG_Py_Void();
37351 return resultobj;
37352 fail:
37353 return NULL;
37354 }
37355
37356
37357 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37358 PyObject *resultobj = 0;
37359 wxWindow *arg1 = (wxWindow *) 0 ;
37360 wxPyDropTarget *result = 0 ;
37361 void *argp1 = 0 ;
37362 int res1 = 0 ;
37363 PyObject *swig_obj[1] ;
37364
37365 if (!args) SWIG_fail;
37366 swig_obj[0] = args;
37367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37368 if (!SWIG_IsOK(res1)) {
37369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
37370 }
37371 arg1 = reinterpret_cast< wxWindow * >(argp1);
37372 {
37373 PyThreadState* __tstate = wxPyBeginAllowThreads();
37374 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
37375 wxPyEndAllowThreads(__tstate);
37376 if (PyErr_Occurred()) SWIG_fail;
37377 }
37378 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
37379 return resultobj;
37380 fail:
37381 return NULL;
37382 }
37383
37384
37385 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37386 PyObject *resultobj = 0;
37387 wxWindow *arg1 = (wxWindow *) 0 ;
37388 bool arg2 ;
37389 void *argp1 = 0 ;
37390 int res1 = 0 ;
37391 bool val2 ;
37392 int ecode2 = 0 ;
37393 PyObject * obj0 = 0 ;
37394 PyObject * obj1 = 0 ;
37395 char * kwnames[] = {
37396 (char *) "self",(char *) "accept", NULL
37397 };
37398
37399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
37400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37401 if (!SWIG_IsOK(res1)) {
37402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
37403 }
37404 arg1 = reinterpret_cast< wxWindow * >(argp1);
37405 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37406 if (!SWIG_IsOK(ecode2)) {
37407 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
37408 }
37409 arg2 = static_cast< bool >(val2);
37410 {
37411 PyThreadState* __tstate = wxPyBeginAllowThreads();
37412 wxWindow_DragAcceptFiles(arg1,arg2);
37413 wxPyEndAllowThreads(__tstate);
37414 if (PyErr_Occurred()) SWIG_fail;
37415 }
37416 resultobj = SWIG_Py_Void();
37417 return resultobj;
37418 fail:
37419 return NULL;
37420 }
37421
37422
37423 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37424 PyObject *resultobj = 0;
37425 wxWindow *arg1 = (wxWindow *) 0 ;
37426 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
37427 void *argp1 = 0 ;
37428 int res1 = 0 ;
37429 int res2 = 0 ;
37430 PyObject * obj0 = 0 ;
37431 PyObject * obj1 = 0 ;
37432 char * kwnames[] = {
37433 (char *) "self",(char *) "constraints", NULL
37434 };
37435
37436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
37437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37438 if (!SWIG_IsOK(res1)) {
37439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
37440 }
37441 arg1 = reinterpret_cast< wxWindow * >(argp1);
37442 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
37443 if (!SWIG_IsOK(res2)) {
37444 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
37445 }
37446 {
37447 PyThreadState* __tstate = wxPyBeginAllowThreads();
37448 (arg1)->SetConstraints(arg2);
37449 wxPyEndAllowThreads(__tstate);
37450 if (PyErr_Occurred()) SWIG_fail;
37451 }
37452 resultobj = SWIG_Py_Void();
37453 return resultobj;
37454 fail:
37455 return NULL;
37456 }
37457
37458
37459 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37460 PyObject *resultobj = 0;
37461 wxWindow *arg1 = (wxWindow *) 0 ;
37462 wxLayoutConstraints *result = 0 ;
37463 void *argp1 = 0 ;
37464 int res1 = 0 ;
37465 PyObject *swig_obj[1] ;
37466
37467 if (!args) SWIG_fail;
37468 swig_obj[0] = args;
37469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37470 if (!SWIG_IsOK(res1)) {
37471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
37472 }
37473 arg1 = reinterpret_cast< wxWindow * >(argp1);
37474 {
37475 PyThreadState* __tstate = wxPyBeginAllowThreads();
37476 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
37477 wxPyEndAllowThreads(__tstate);
37478 if (PyErr_Occurred()) SWIG_fail;
37479 }
37480 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
37481 return resultobj;
37482 fail:
37483 return NULL;
37484 }
37485
37486
37487 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37488 PyObject *resultobj = 0;
37489 wxWindow *arg1 = (wxWindow *) 0 ;
37490 bool arg2 ;
37491 void *argp1 = 0 ;
37492 int res1 = 0 ;
37493 bool val2 ;
37494 int ecode2 = 0 ;
37495 PyObject * obj0 = 0 ;
37496 PyObject * obj1 = 0 ;
37497 char * kwnames[] = {
37498 (char *) "self",(char *) "autoLayout", NULL
37499 };
37500
37501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
37502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37503 if (!SWIG_IsOK(res1)) {
37504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
37505 }
37506 arg1 = reinterpret_cast< wxWindow * >(argp1);
37507 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37508 if (!SWIG_IsOK(ecode2)) {
37509 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
37510 }
37511 arg2 = static_cast< bool >(val2);
37512 {
37513 PyThreadState* __tstate = wxPyBeginAllowThreads();
37514 (arg1)->SetAutoLayout(arg2);
37515 wxPyEndAllowThreads(__tstate);
37516 if (PyErr_Occurred()) SWIG_fail;
37517 }
37518 resultobj = SWIG_Py_Void();
37519 return resultobj;
37520 fail:
37521 return NULL;
37522 }
37523
37524
37525 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37526 PyObject *resultobj = 0;
37527 wxWindow *arg1 = (wxWindow *) 0 ;
37528 bool result;
37529 void *argp1 = 0 ;
37530 int res1 = 0 ;
37531 PyObject *swig_obj[1] ;
37532
37533 if (!args) SWIG_fail;
37534 swig_obj[0] = args;
37535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37536 if (!SWIG_IsOK(res1)) {
37537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
37538 }
37539 arg1 = reinterpret_cast< wxWindow * >(argp1);
37540 {
37541 PyThreadState* __tstate = wxPyBeginAllowThreads();
37542 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
37543 wxPyEndAllowThreads(__tstate);
37544 if (PyErr_Occurred()) SWIG_fail;
37545 }
37546 {
37547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37548 }
37549 return resultobj;
37550 fail:
37551 return NULL;
37552 }
37553
37554
37555 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37556 PyObject *resultobj = 0;
37557 wxWindow *arg1 = (wxWindow *) 0 ;
37558 bool result;
37559 void *argp1 = 0 ;
37560 int res1 = 0 ;
37561 PyObject *swig_obj[1] ;
37562
37563 if (!args) SWIG_fail;
37564 swig_obj[0] = args;
37565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37566 if (!SWIG_IsOK(res1)) {
37567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
37568 }
37569 arg1 = reinterpret_cast< wxWindow * >(argp1);
37570 {
37571 PyThreadState* __tstate = wxPyBeginAllowThreads();
37572 result = (bool)(arg1)->Layout();
37573 wxPyEndAllowThreads(__tstate);
37574 if (PyErr_Occurred()) SWIG_fail;
37575 }
37576 {
37577 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37578 }
37579 return resultobj;
37580 fail:
37581 return NULL;
37582 }
37583
37584
37585 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37586 PyObject *resultobj = 0;
37587 wxWindow *arg1 = (wxWindow *) 0 ;
37588 wxSizer *arg2 = (wxSizer *) 0 ;
37589 bool arg3 = (bool) true ;
37590 void *argp1 = 0 ;
37591 int res1 = 0 ;
37592 int res2 = 0 ;
37593 bool val3 ;
37594 int ecode3 = 0 ;
37595 PyObject * obj0 = 0 ;
37596 PyObject * obj1 = 0 ;
37597 PyObject * obj2 = 0 ;
37598 char * kwnames[] = {
37599 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37600 };
37601
37602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) 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_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37606 }
37607 arg1 = reinterpret_cast< wxWindow * >(argp1);
37608 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37609 if (!SWIG_IsOK(res2)) {
37610 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37611 }
37612 if (obj2) {
37613 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37614 if (!SWIG_IsOK(ecode3)) {
37615 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
37616 }
37617 arg3 = static_cast< bool >(val3);
37618 }
37619 {
37620 PyThreadState* __tstate = wxPyBeginAllowThreads();
37621 (arg1)->SetSizer(arg2,arg3);
37622 wxPyEndAllowThreads(__tstate);
37623 if (PyErr_Occurred()) SWIG_fail;
37624 }
37625 resultobj = SWIG_Py_Void();
37626 return resultobj;
37627 fail:
37628 return NULL;
37629 }
37630
37631
37632 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37633 PyObject *resultobj = 0;
37634 wxWindow *arg1 = (wxWindow *) 0 ;
37635 wxSizer *arg2 = (wxSizer *) 0 ;
37636 bool arg3 = (bool) true ;
37637 void *argp1 = 0 ;
37638 int res1 = 0 ;
37639 int res2 = 0 ;
37640 bool val3 ;
37641 int ecode3 = 0 ;
37642 PyObject * obj0 = 0 ;
37643 PyObject * obj1 = 0 ;
37644 PyObject * obj2 = 0 ;
37645 char * kwnames[] = {
37646 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37647 };
37648
37649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37651 if (!SWIG_IsOK(res1)) {
37652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
37653 }
37654 arg1 = reinterpret_cast< wxWindow * >(argp1);
37655 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37656 if (!SWIG_IsOK(res2)) {
37657 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
37658 }
37659 if (obj2) {
37660 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37661 if (!SWIG_IsOK(ecode3)) {
37662 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
37663 }
37664 arg3 = static_cast< bool >(val3);
37665 }
37666 {
37667 PyThreadState* __tstate = wxPyBeginAllowThreads();
37668 (arg1)->SetSizerAndFit(arg2,arg3);
37669 wxPyEndAllowThreads(__tstate);
37670 if (PyErr_Occurred()) SWIG_fail;
37671 }
37672 resultobj = SWIG_Py_Void();
37673 return resultobj;
37674 fail:
37675 return NULL;
37676 }
37677
37678
37679 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37680 PyObject *resultobj = 0;
37681 wxWindow *arg1 = (wxWindow *) 0 ;
37682 wxSizer *result = 0 ;
37683 void *argp1 = 0 ;
37684 int res1 = 0 ;
37685 PyObject *swig_obj[1] ;
37686
37687 if (!args) SWIG_fail;
37688 swig_obj[0] = args;
37689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37690 if (!SWIG_IsOK(res1)) {
37691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37692 }
37693 arg1 = reinterpret_cast< wxWindow * >(argp1);
37694 {
37695 PyThreadState* __tstate = wxPyBeginAllowThreads();
37696 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
37697 wxPyEndAllowThreads(__tstate);
37698 if (PyErr_Occurred()) SWIG_fail;
37699 }
37700 {
37701 resultobj = wxPyMake_wxObject(result, (bool)0);
37702 }
37703 return resultobj;
37704 fail:
37705 return NULL;
37706 }
37707
37708
37709 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37710 PyObject *resultobj = 0;
37711 wxWindow *arg1 = (wxWindow *) 0 ;
37712 wxSizer *arg2 = (wxSizer *) 0 ;
37713 void *argp1 = 0 ;
37714 int res1 = 0 ;
37715 void *argp2 = 0 ;
37716 int res2 = 0 ;
37717 PyObject * obj0 = 0 ;
37718 PyObject * obj1 = 0 ;
37719 char * kwnames[] = {
37720 (char *) "self",(char *) "sizer", NULL
37721 };
37722
37723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
37724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37725 if (!SWIG_IsOK(res1)) {
37726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37727 }
37728 arg1 = reinterpret_cast< wxWindow * >(argp1);
37729 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
37730 if (!SWIG_IsOK(res2)) {
37731 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37732 }
37733 arg2 = reinterpret_cast< wxSizer * >(argp2);
37734 {
37735 PyThreadState* __tstate = wxPyBeginAllowThreads();
37736 (arg1)->SetContainingSizer(arg2);
37737 wxPyEndAllowThreads(__tstate);
37738 if (PyErr_Occurred()) SWIG_fail;
37739 }
37740 resultobj = SWIG_Py_Void();
37741 return resultobj;
37742 fail:
37743 return NULL;
37744 }
37745
37746
37747 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37748 PyObject *resultobj = 0;
37749 wxWindow *arg1 = (wxWindow *) 0 ;
37750 wxSizer *result = 0 ;
37751 void *argp1 = 0 ;
37752 int res1 = 0 ;
37753 PyObject *swig_obj[1] ;
37754
37755 if (!args) SWIG_fail;
37756 swig_obj[0] = args;
37757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37758 if (!SWIG_IsOK(res1)) {
37759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37760 }
37761 arg1 = reinterpret_cast< wxWindow * >(argp1);
37762 {
37763 PyThreadState* __tstate = wxPyBeginAllowThreads();
37764 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
37765 wxPyEndAllowThreads(__tstate);
37766 if (PyErr_Occurred()) SWIG_fail;
37767 }
37768 {
37769 resultobj = wxPyMake_wxObject(result, (bool)0);
37770 }
37771 return resultobj;
37772 fail:
37773 return NULL;
37774 }
37775
37776
37777 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37778 PyObject *resultobj = 0;
37779 wxWindow *arg1 = (wxWindow *) 0 ;
37780 void *argp1 = 0 ;
37781 int res1 = 0 ;
37782 PyObject *swig_obj[1] ;
37783
37784 if (!args) SWIG_fail;
37785 swig_obj[0] = args;
37786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37787 if (!SWIG_IsOK(res1)) {
37788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
37789 }
37790 arg1 = reinterpret_cast< wxWindow * >(argp1);
37791 {
37792 PyThreadState* __tstate = wxPyBeginAllowThreads();
37793 (arg1)->InheritAttributes();
37794 wxPyEndAllowThreads(__tstate);
37795 if (PyErr_Occurred()) SWIG_fail;
37796 }
37797 resultobj = SWIG_Py_Void();
37798 return resultobj;
37799 fail:
37800 return NULL;
37801 }
37802
37803
37804 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37805 PyObject *resultobj = 0;
37806 wxWindow *arg1 = (wxWindow *) 0 ;
37807 bool result;
37808 void *argp1 = 0 ;
37809 int res1 = 0 ;
37810 PyObject *swig_obj[1] ;
37811
37812 if (!args) SWIG_fail;
37813 swig_obj[0] = args;
37814 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37815 if (!SWIG_IsOK(res1)) {
37816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
37817 }
37818 arg1 = reinterpret_cast< wxWindow * >(argp1);
37819 {
37820 PyThreadState* __tstate = wxPyBeginAllowThreads();
37821 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
37822 wxPyEndAllowThreads(__tstate);
37823 if (PyErr_Occurred()) SWIG_fail;
37824 }
37825 {
37826 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37827 }
37828 return resultobj;
37829 fail:
37830 return NULL;
37831 }
37832
37833
37834 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37835 PyObject *resultobj = 0;
37836 wxWindow *arg1 = (wxWindow *) 0 ;
37837 bool result;
37838 void *argp1 = 0 ;
37839 int res1 = 0 ;
37840 PyObject *swig_obj[1] ;
37841
37842 if (!args) SWIG_fail;
37843 swig_obj[0] = args;
37844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37845 if (!SWIG_IsOK(res1)) {
37846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
37847 }
37848 arg1 = reinterpret_cast< wxWindow * >(argp1);
37849 {
37850 PyThreadState* __tstate = wxPyBeginAllowThreads();
37851 result = (bool)(arg1)->CanSetTransparent();
37852 wxPyEndAllowThreads(__tstate);
37853 if (PyErr_Occurred()) SWIG_fail;
37854 }
37855 {
37856 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37857 }
37858 return resultobj;
37859 fail:
37860 return NULL;
37861 }
37862
37863
37864 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37865 PyObject *resultobj = 0;
37866 wxWindow *arg1 = (wxWindow *) 0 ;
37867 byte arg2 ;
37868 bool result;
37869 void *argp1 = 0 ;
37870 int res1 = 0 ;
37871 unsigned char val2 ;
37872 int ecode2 = 0 ;
37873 PyObject * obj0 = 0 ;
37874 PyObject * obj1 = 0 ;
37875 char * kwnames[] = {
37876 (char *) "self",(char *) "alpha", NULL
37877 };
37878
37879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
37880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37881 if (!SWIG_IsOK(res1)) {
37882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
37883 }
37884 arg1 = reinterpret_cast< wxWindow * >(argp1);
37885 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
37886 if (!SWIG_IsOK(ecode2)) {
37887 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
37888 }
37889 arg2 = static_cast< byte >(val2);
37890 {
37891 PyThreadState* __tstate = wxPyBeginAllowThreads();
37892 result = (bool)(arg1)->SetTransparent(arg2);
37893 wxPyEndAllowThreads(__tstate);
37894 if (PyErr_Occurred()) SWIG_fail;
37895 }
37896 {
37897 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37898 }
37899 return resultobj;
37900 fail:
37901 return NULL;
37902 }
37903
37904
37905 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37906 PyObject *obj;
37907 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37908 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
37909 return SWIG_Py_Void();
37910 }
37911
37912 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37913 return SWIG_Python_InitShadowInstance(args);
37914 }
37915
37916 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37917 PyObject *resultobj = 0;
37918 long arg1 ;
37919 wxWindow *arg2 = (wxWindow *) NULL ;
37920 wxWindow *result = 0 ;
37921 long val1 ;
37922 int ecode1 = 0 ;
37923 void *argp2 = 0 ;
37924 int res2 = 0 ;
37925 PyObject * obj0 = 0 ;
37926 PyObject * obj1 = 0 ;
37927 char * kwnames[] = {
37928 (char *) "id",(char *) "parent", NULL
37929 };
37930
37931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
37932 ecode1 = SWIG_AsVal_long(obj0, &val1);
37933 if (!SWIG_IsOK(ecode1)) {
37934 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
37935 }
37936 arg1 = static_cast< long >(val1);
37937 if (obj1) {
37938 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37939 if (!SWIG_IsOK(res2)) {
37940 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
37941 }
37942 arg2 = reinterpret_cast< wxWindow * >(argp2);
37943 }
37944 {
37945 if (!wxPyCheckForApp()) SWIG_fail;
37946 PyThreadState* __tstate = wxPyBeginAllowThreads();
37947 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
37948 wxPyEndAllowThreads(__tstate);
37949 if (PyErr_Occurred()) SWIG_fail;
37950 }
37951 {
37952 resultobj = wxPyMake_wxObject(result, 0);
37953 }
37954 return resultobj;
37955 fail:
37956 return NULL;
37957 }
37958
37959
37960 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37961 PyObject *resultobj = 0;
37962 wxString *arg1 = 0 ;
37963 wxWindow *arg2 = (wxWindow *) NULL ;
37964 wxWindow *result = 0 ;
37965 bool temp1 = false ;
37966 void *argp2 = 0 ;
37967 int res2 = 0 ;
37968 PyObject * obj0 = 0 ;
37969 PyObject * obj1 = 0 ;
37970 char * kwnames[] = {
37971 (char *) "name",(char *) "parent", NULL
37972 };
37973
37974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
37975 {
37976 arg1 = wxString_in_helper(obj0);
37977 if (arg1 == NULL) SWIG_fail;
37978 temp1 = true;
37979 }
37980 if (obj1) {
37981 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37982 if (!SWIG_IsOK(res2)) {
37983 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
37984 }
37985 arg2 = reinterpret_cast< wxWindow * >(argp2);
37986 }
37987 {
37988 if (!wxPyCheckForApp()) SWIG_fail;
37989 PyThreadState* __tstate = wxPyBeginAllowThreads();
37990 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
37991 wxPyEndAllowThreads(__tstate);
37992 if (PyErr_Occurred()) SWIG_fail;
37993 }
37994 {
37995 resultobj = wxPyMake_wxObject(result, 0);
37996 }
37997 {
37998 if (temp1)
37999 delete arg1;
38000 }
38001 return resultobj;
38002 fail:
38003 {
38004 if (temp1)
38005 delete arg1;
38006 }
38007 return NULL;
38008 }
38009
38010
38011 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38012 PyObject *resultobj = 0;
38013 wxString *arg1 = 0 ;
38014 wxWindow *arg2 = (wxWindow *) NULL ;
38015 wxWindow *result = 0 ;
38016 bool temp1 = false ;
38017 void *argp2 = 0 ;
38018 int res2 = 0 ;
38019 PyObject * obj0 = 0 ;
38020 PyObject * obj1 = 0 ;
38021 char * kwnames[] = {
38022 (char *) "label",(char *) "parent", NULL
38023 };
38024
38025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
38026 {
38027 arg1 = wxString_in_helper(obj0);
38028 if (arg1 == NULL) SWIG_fail;
38029 temp1 = true;
38030 }
38031 if (obj1) {
38032 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38033 if (!SWIG_IsOK(res2)) {
38034 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
38035 }
38036 arg2 = reinterpret_cast< wxWindow * >(argp2);
38037 }
38038 {
38039 if (!wxPyCheckForApp()) SWIG_fail;
38040 PyThreadState* __tstate = wxPyBeginAllowThreads();
38041 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
38042 wxPyEndAllowThreads(__tstate);
38043 if (PyErr_Occurred()) SWIG_fail;
38044 }
38045 {
38046 resultobj = wxPyMake_wxObject(result, 0);
38047 }
38048 {
38049 if (temp1)
38050 delete arg1;
38051 }
38052 return resultobj;
38053 fail:
38054 {
38055 if (temp1)
38056 delete arg1;
38057 }
38058 return NULL;
38059 }
38060
38061
38062 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38063 PyObject *resultobj = 0;
38064 wxWindow *arg1 = (wxWindow *) 0 ;
38065 unsigned long arg2 ;
38066 wxWindow *result = 0 ;
38067 void *argp1 = 0 ;
38068 int res1 = 0 ;
38069 unsigned long val2 ;
38070 int ecode2 = 0 ;
38071 PyObject * obj0 = 0 ;
38072 PyObject * obj1 = 0 ;
38073 char * kwnames[] = {
38074 (char *) "parent",(char *) "_hWnd", NULL
38075 };
38076
38077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
38078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38079 if (!SWIG_IsOK(res1)) {
38080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
38081 }
38082 arg1 = reinterpret_cast< wxWindow * >(argp1);
38083 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
38084 if (!SWIG_IsOK(ecode2)) {
38085 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
38086 }
38087 arg2 = static_cast< unsigned long >(val2);
38088 {
38089 PyThreadState* __tstate = wxPyBeginAllowThreads();
38090 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
38091 wxPyEndAllowThreads(__tstate);
38092 if (PyErr_Occurred()) SWIG_fail;
38093 }
38094 {
38095 resultobj = wxPyMake_wxObject(result, 0);
38096 }
38097 return resultobj;
38098 fail:
38099 return NULL;
38100 }
38101
38102
38103 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38104 PyObject *resultobj = 0;
38105 PyObject *result = 0 ;
38106
38107 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
38108 {
38109 PyThreadState* __tstate = wxPyBeginAllowThreads();
38110 result = (PyObject *)GetTopLevelWindows();
38111 wxPyEndAllowThreads(__tstate);
38112 if (PyErr_Occurred()) SWIG_fail;
38113 }
38114 resultobj = result;
38115 return resultobj;
38116 fail:
38117 return NULL;
38118 }
38119
38120
38121 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38122 PyObject *resultobj = 0;
38123 wxValidator *result = 0 ;
38124
38125 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
38126 {
38127 PyThreadState* __tstate = wxPyBeginAllowThreads();
38128 result = (wxValidator *)new wxValidator();
38129 wxPyEndAllowThreads(__tstate);
38130 if (PyErr_Occurred()) SWIG_fail;
38131 }
38132 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
38133 return resultobj;
38134 fail:
38135 return NULL;
38136 }
38137
38138
38139 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38140 PyObject *resultobj = 0;
38141 wxValidator *arg1 = (wxValidator *) 0 ;
38142 wxValidator *result = 0 ;
38143 void *argp1 = 0 ;
38144 int res1 = 0 ;
38145 PyObject *swig_obj[1] ;
38146
38147 if (!args) SWIG_fail;
38148 swig_obj[0] = args;
38149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38150 if (!SWIG_IsOK(res1)) {
38151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
38152 }
38153 arg1 = reinterpret_cast< wxValidator * >(argp1);
38154 {
38155 PyThreadState* __tstate = wxPyBeginAllowThreads();
38156 result = (wxValidator *)(arg1)->Clone();
38157 wxPyEndAllowThreads(__tstate);
38158 if (PyErr_Occurred()) SWIG_fail;
38159 }
38160 {
38161 resultobj = wxPyMake_wxObject(result, 0);
38162 }
38163 return resultobj;
38164 fail:
38165 return NULL;
38166 }
38167
38168
38169 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38170 PyObject *resultobj = 0;
38171 wxValidator *arg1 = (wxValidator *) 0 ;
38172 wxWindow *arg2 = (wxWindow *) 0 ;
38173 bool result;
38174 void *argp1 = 0 ;
38175 int res1 = 0 ;
38176 void *argp2 = 0 ;
38177 int res2 = 0 ;
38178 PyObject * obj0 = 0 ;
38179 PyObject * obj1 = 0 ;
38180 char * kwnames[] = {
38181 (char *) "self",(char *) "parent", NULL
38182 };
38183
38184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
38185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38186 if (!SWIG_IsOK(res1)) {
38187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
38188 }
38189 arg1 = reinterpret_cast< wxValidator * >(argp1);
38190 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38191 if (!SWIG_IsOK(res2)) {
38192 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
38193 }
38194 arg2 = reinterpret_cast< wxWindow * >(argp2);
38195 {
38196 PyThreadState* __tstate = wxPyBeginAllowThreads();
38197 result = (bool)(arg1)->Validate(arg2);
38198 wxPyEndAllowThreads(__tstate);
38199 if (PyErr_Occurred()) SWIG_fail;
38200 }
38201 {
38202 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38203 }
38204 return resultobj;
38205 fail:
38206 return NULL;
38207 }
38208
38209
38210 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38211 PyObject *resultobj = 0;
38212 wxValidator *arg1 = (wxValidator *) 0 ;
38213 bool result;
38214 void *argp1 = 0 ;
38215 int res1 = 0 ;
38216 PyObject *swig_obj[1] ;
38217
38218 if (!args) SWIG_fail;
38219 swig_obj[0] = args;
38220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38221 if (!SWIG_IsOK(res1)) {
38222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38223 }
38224 arg1 = reinterpret_cast< wxValidator * >(argp1);
38225 {
38226 PyThreadState* __tstate = wxPyBeginAllowThreads();
38227 result = (bool)(arg1)->TransferToWindow();
38228 wxPyEndAllowThreads(__tstate);
38229 if (PyErr_Occurred()) SWIG_fail;
38230 }
38231 {
38232 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38233 }
38234 return resultobj;
38235 fail:
38236 return NULL;
38237 }
38238
38239
38240 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38241 PyObject *resultobj = 0;
38242 wxValidator *arg1 = (wxValidator *) 0 ;
38243 bool result;
38244 void *argp1 = 0 ;
38245 int res1 = 0 ;
38246 PyObject *swig_obj[1] ;
38247
38248 if (!args) SWIG_fail;
38249 swig_obj[0] = args;
38250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38251 if (!SWIG_IsOK(res1)) {
38252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38253 }
38254 arg1 = reinterpret_cast< wxValidator * >(argp1);
38255 {
38256 PyThreadState* __tstate = wxPyBeginAllowThreads();
38257 result = (bool)(arg1)->TransferFromWindow();
38258 wxPyEndAllowThreads(__tstate);
38259 if (PyErr_Occurred()) SWIG_fail;
38260 }
38261 {
38262 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38263 }
38264 return resultobj;
38265 fail:
38266 return NULL;
38267 }
38268
38269
38270 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38271 PyObject *resultobj = 0;
38272 wxValidator *arg1 = (wxValidator *) 0 ;
38273 wxWindow *result = 0 ;
38274 void *argp1 = 0 ;
38275 int res1 = 0 ;
38276 PyObject *swig_obj[1] ;
38277
38278 if (!args) SWIG_fail;
38279 swig_obj[0] = args;
38280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38281 if (!SWIG_IsOK(res1)) {
38282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38283 }
38284 arg1 = reinterpret_cast< wxValidator * >(argp1);
38285 {
38286 PyThreadState* __tstate = wxPyBeginAllowThreads();
38287 result = (wxWindow *)(arg1)->GetWindow();
38288 wxPyEndAllowThreads(__tstate);
38289 if (PyErr_Occurred()) SWIG_fail;
38290 }
38291 {
38292 resultobj = wxPyMake_wxObject(result, 0);
38293 }
38294 return resultobj;
38295 fail:
38296 return NULL;
38297 }
38298
38299
38300 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38301 PyObject *resultobj = 0;
38302 wxValidator *arg1 = (wxValidator *) 0 ;
38303 wxWindow *arg2 = (wxWindow *) 0 ;
38304 void *argp1 = 0 ;
38305 int res1 = 0 ;
38306 void *argp2 = 0 ;
38307 int res2 = 0 ;
38308 PyObject * obj0 = 0 ;
38309 PyObject * obj1 = 0 ;
38310 char * kwnames[] = {
38311 (char *) "self",(char *) "window", NULL
38312 };
38313
38314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
38315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38316 if (!SWIG_IsOK(res1)) {
38317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38318 }
38319 arg1 = reinterpret_cast< wxValidator * >(argp1);
38320 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38321 if (!SWIG_IsOK(res2)) {
38322 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
38323 }
38324 arg2 = reinterpret_cast< wxWindow * >(argp2);
38325 {
38326 PyThreadState* __tstate = wxPyBeginAllowThreads();
38327 (arg1)->SetWindow(arg2);
38328 wxPyEndAllowThreads(__tstate);
38329 if (PyErr_Occurred()) SWIG_fail;
38330 }
38331 resultobj = SWIG_Py_Void();
38332 return resultobj;
38333 fail:
38334 return NULL;
38335 }
38336
38337
38338 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38339 PyObject *resultobj = 0;
38340 bool result;
38341
38342 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
38343 {
38344 PyThreadState* __tstate = wxPyBeginAllowThreads();
38345 result = (bool)wxValidator::IsSilent();
38346 wxPyEndAllowThreads(__tstate);
38347 if (PyErr_Occurred()) SWIG_fail;
38348 }
38349 {
38350 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38351 }
38352 return resultobj;
38353 fail:
38354 return NULL;
38355 }
38356
38357
38358 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38359 PyObject *resultobj = 0;
38360 int arg1 = (int) true ;
38361 int val1 ;
38362 int ecode1 = 0 ;
38363 PyObject * obj0 = 0 ;
38364 char * kwnames[] = {
38365 (char *) "doIt", NULL
38366 };
38367
38368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
38369 if (obj0) {
38370 ecode1 = SWIG_AsVal_int(obj0, &val1);
38371 if (!SWIG_IsOK(ecode1)) {
38372 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
38373 }
38374 arg1 = static_cast< int >(val1);
38375 }
38376 {
38377 PyThreadState* __tstate = wxPyBeginAllowThreads();
38378 wxValidator::SetBellOnError(arg1);
38379 wxPyEndAllowThreads(__tstate);
38380 if (PyErr_Occurred()) SWIG_fail;
38381 }
38382 resultobj = SWIG_Py_Void();
38383 return resultobj;
38384 fail:
38385 return NULL;
38386 }
38387
38388
38389 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38390 PyObject *obj;
38391 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38392 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
38393 return SWIG_Py_Void();
38394 }
38395
38396 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38397 return SWIG_Python_InitShadowInstance(args);
38398 }
38399
38400 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38401 PyObject *resultobj = 0;
38402 wxPyValidator *result = 0 ;
38403
38404 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
38405 {
38406 PyThreadState* __tstate = wxPyBeginAllowThreads();
38407 result = (wxPyValidator *)new wxPyValidator();
38408 wxPyEndAllowThreads(__tstate);
38409 if (PyErr_Occurred()) SWIG_fail;
38410 }
38411 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
38412 return resultobj;
38413 fail:
38414 return NULL;
38415 }
38416
38417
38418 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38419 PyObject *resultobj = 0;
38420 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
38421 PyObject *arg2 = (PyObject *) 0 ;
38422 PyObject *arg3 = (PyObject *) 0 ;
38423 int arg4 = (int) true ;
38424 void *argp1 = 0 ;
38425 int res1 = 0 ;
38426 int val4 ;
38427 int ecode4 = 0 ;
38428 PyObject * obj0 = 0 ;
38429 PyObject * obj1 = 0 ;
38430 PyObject * obj2 = 0 ;
38431 PyObject * obj3 = 0 ;
38432 char * kwnames[] = {
38433 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
38434 };
38435
38436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
38438 if (!SWIG_IsOK(res1)) {
38439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
38440 }
38441 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
38442 arg2 = obj1;
38443 arg3 = obj2;
38444 if (obj3) {
38445 ecode4 = SWIG_AsVal_int(obj3, &val4);
38446 if (!SWIG_IsOK(ecode4)) {
38447 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
38448 }
38449 arg4 = static_cast< int >(val4);
38450 }
38451 {
38452 PyThreadState* __tstate = wxPyBeginAllowThreads();
38453 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
38454 wxPyEndAllowThreads(__tstate);
38455 if (PyErr_Occurred()) SWIG_fail;
38456 }
38457 resultobj = SWIG_Py_Void();
38458 return resultobj;
38459 fail:
38460 return NULL;
38461 }
38462
38463
38464 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38465 PyObject *obj;
38466 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38467 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
38468 return SWIG_Py_Void();
38469 }
38470
38471 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38472 return SWIG_Python_InitShadowInstance(args);
38473 }
38474
38475 SWIGINTERN int DefaultValidator_set(PyObject *) {
38476 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
38477 return 1;
38478 }
38479
38480
38481 SWIGINTERN PyObject *DefaultValidator_get(void) {
38482 PyObject *pyobj = 0;
38483
38484 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
38485 return pyobj;
38486 }
38487
38488
38489 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38490 PyObject *resultobj = 0;
38491 wxString const &arg1_defvalue = wxPyEmptyString ;
38492 wxString *arg1 = (wxString *) &arg1_defvalue ;
38493 long arg2 = (long) 0 ;
38494 wxMenu *result = 0 ;
38495 bool temp1 = false ;
38496 long val2 ;
38497 int ecode2 = 0 ;
38498 PyObject * obj0 = 0 ;
38499 PyObject * obj1 = 0 ;
38500 char * kwnames[] = {
38501 (char *) "title",(char *) "style", NULL
38502 };
38503
38504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
38505 if (obj0) {
38506 {
38507 arg1 = wxString_in_helper(obj0);
38508 if (arg1 == NULL) SWIG_fail;
38509 temp1 = true;
38510 }
38511 }
38512 if (obj1) {
38513 ecode2 = SWIG_AsVal_long(obj1, &val2);
38514 if (!SWIG_IsOK(ecode2)) {
38515 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
38516 }
38517 arg2 = static_cast< long >(val2);
38518 }
38519 {
38520 if (!wxPyCheckForApp()) SWIG_fail;
38521 PyThreadState* __tstate = wxPyBeginAllowThreads();
38522 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
38523 wxPyEndAllowThreads(__tstate);
38524 if (PyErr_Occurred()) SWIG_fail;
38525 }
38526 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
38527 {
38528 if (temp1)
38529 delete arg1;
38530 }
38531 return resultobj;
38532 fail:
38533 {
38534 if (temp1)
38535 delete arg1;
38536 }
38537 return NULL;
38538 }
38539
38540
38541 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38542 PyObject *resultobj = 0;
38543 wxMenu *arg1 = (wxMenu *) 0 ;
38544 int arg2 ;
38545 wxString *arg3 = 0 ;
38546 wxString const &arg4_defvalue = wxPyEmptyString ;
38547 wxString *arg4 = (wxString *) &arg4_defvalue ;
38548 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38549 wxMenuItem *result = 0 ;
38550 void *argp1 = 0 ;
38551 int res1 = 0 ;
38552 int val2 ;
38553 int ecode2 = 0 ;
38554 bool temp3 = false ;
38555 bool temp4 = false ;
38556 int val5 ;
38557 int ecode5 = 0 ;
38558 PyObject * obj0 = 0 ;
38559 PyObject * obj1 = 0 ;
38560 PyObject * obj2 = 0 ;
38561 PyObject * obj3 = 0 ;
38562 PyObject * obj4 = 0 ;
38563 char * kwnames[] = {
38564 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38565 };
38566
38567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38569 if (!SWIG_IsOK(res1)) {
38570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
38571 }
38572 arg1 = reinterpret_cast< wxMenu * >(argp1);
38573 ecode2 = SWIG_AsVal_int(obj1, &val2);
38574 if (!SWIG_IsOK(ecode2)) {
38575 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
38576 }
38577 arg2 = static_cast< int >(val2);
38578 {
38579 arg3 = wxString_in_helper(obj2);
38580 if (arg3 == NULL) SWIG_fail;
38581 temp3 = true;
38582 }
38583 if (obj3) {
38584 {
38585 arg4 = wxString_in_helper(obj3);
38586 if (arg4 == NULL) SWIG_fail;
38587 temp4 = true;
38588 }
38589 }
38590 if (obj4) {
38591 ecode5 = SWIG_AsVal_int(obj4, &val5);
38592 if (!SWIG_IsOK(ecode5)) {
38593 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
38594 }
38595 arg5 = static_cast< wxItemKind >(val5);
38596 }
38597 {
38598 PyThreadState* __tstate = wxPyBeginAllowThreads();
38599 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
38600 wxPyEndAllowThreads(__tstate);
38601 if (PyErr_Occurred()) SWIG_fail;
38602 }
38603 {
38604 resultobj = wxPyMake_wxObject(result, (bool)0);
38605 }
38606 {
38607 if (temp3)
38608 delete arg3;
38609 }
38610 {
38611 if (temp4)
38612 delete arg4;
38613 }
38614 return resultobj;
38615 fail:
38616 {
38617 if (temp3)
38618 delete arg3;
38619 }
38620 {
38621 if (temp4)
38622 delete arg4;
38623 }
38624 return NULL;
38625 }
38626
38627
38628 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38629 PyObject *resultobj = 0;
38630 wxMenu *arg1 = (wxMenu *) 0 ;
38631 wxMenuItem *result = 0 ;
38632 void *argp1 = 0 ;
38633 int res1 = 0 ;
38634 PyObject *swig_obj[1] ;
38635
38636 if (!args) SWIG_fail;
38637 swig_obj[0] = args;
38638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38639 if (!SWIG_IsOK(res1)) {
38640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38641 }
38642 arg1 = reinterpret_cast< wxMenu * >(argp1);
38643 {
38644 PyThreadState* __tstate = wxPyBeginAllowThreads();
38645 result = (wxMenuItem *)(arg1)->AppendSeparator();
38646 wxPyEndAllowThreads(__tstate);
38647 if (PyErr_Occurred()) SWIG_fail;
38648 }
38649 {
38650 resultobj = wxPyMake_wxObject(result, (bool)0);
38651 }
38652 return resultobj;
38653 fail:
38654 return NULL;
38655 }
38656
38657
38658 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38659 PyObject *resultobj = 0;
38660 wxMenu *arg1 = (wxMenu *) 0 ;
38661 int arg2 ;
38662 wxString *arg3 = 0 ;
38663 wxString const &arg4_defvalue = wxPyEmptyString ;
38664 wxString *arg4 = (wxString *) &arg4_defvalue ;
38665 wxMenuItem *result = 0 ;
38666 void *argp1 = 0 ;
38667 int res1 = 0 ;
38668 int val2 ;
38669 int ecode2 = 0 ;
38670 bool temp3 = false ;
38671 bool temp4 = false ;
38672 PyObject * obj0 = 0 ;
38673 PyObject * obj1 = 0 ;
38674 PyObject * obj2 = 0 ;
38675 PyObject * obj3 = 0 ;
38676 char * kwnames[] = {
38677 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38678 };
38679
38680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38682 if (!SWIG_IsOK(res1)) {
38683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38684 }
38685 arg1 = reinterpret_cast< wxMenu * >(argp1);
38686 ecode2 = SWIG_AsVal_int(obj1, &val2);
38687 if (!SWIG_IsOK(ecode2)) {
38688 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
38689 }
38690 arg2 = static_cast< int >(val2);
38691 {
38692 arg3 = wxString_in_helper(obj2);
38693 if (arg3 == NULL) SWIG_fail;
38694 temp3 = true;
38695 }
38696 if (obj3) {
38697 {
38698 arg4 = wxString_in_helper(obj3);
38699 if (arg4 == NULL) SWIG_fail;
38700 temp4 = true;
38701 }
38702 }
38703 {
38704 PyThreadState* __tstate = wxPyBeginAllowThreads();
38705 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38706 wxPyEndAllowThreads(__tstate);
38707 if (PyErr_Occurred()) SWIG_fail;
38708 }
38709 {
38710 resultobj = wxPyMake_wxObject(result, (bool)0);
38711 }
38712 {
38713 if (temp3)
38714 delete arg3;
38715 }
38716 {
38717 if (temp4)
38718 delete arg4;
38719 }
38720 return resultobj;
38721 fail:
38722 {
38723 if (temp3)
38724 delete arg3;
38725 }
38726 {
38727 if (temp4)
38728 delete arg4;
38729 }
38730 return NULL;
38731 }
38732
38733
38734 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38735 PyObject *resultobj = 0;
38736 wxMenu *arg1 = (wxMenu *) 0 ;
38737 int arg2 ;
38738 wxString *arg3 = 0 ;
38739 wxString const &arg4_defvalue = wxPyEmptyString ;
38740 wxString *arg4 = (wxString *) &arg4_defvalue ;
38741 wxMenuItem *result = 0 ;
38742 void *argp1 = 0 ;
38743 int res1 = 0 ;
38744 int val2 ;
38745 int ecode2 = 0 ;
38746 bool temp3 = false ;
38747 bool temp4 = false ;
38748 PyObject * obj0 = 0 ;
38749 PyObject * obj1 = 0 ;
38750 PyObject * obj2 = 0 ;
38751 PyObject * obj3 = 0 ;
38752 char * kwnames[] = {
38753 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38754 };
38755
38756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38758 if (!SWIG_IsOK(res1)) {
38759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38760 }
38761 arg1 = reinterpret_cast< wxMenu * >(argp1);
38762 ecode2 = SWIG_AsVal_int(obj1, &val2);
38763 if (!SWIG_IsOK(ecode2)) {
38764 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
38765 }
38766 arg2 = static_cast< int >(val2);
38767 {
38768 arg3 = wxString_in_helper(obj2);
38769 if (arg3 == NULL) SWIG_fail;
38770 temp3 = true;
38771 }
38772 if (obj3) {
38773 {
38774 arg4 = wxString_in_helper(obj3);
38775 if (arg4 == NULL) SWIG_fail;
38776 temp4 = true;
38777 }
38778 }
38779 {
38780 PyThreadState* __tstate = wxPyBeginAllowThreads();
38781 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38782 wxPyEndAllowThreads(__tstate);
38783 if (PyErr_Occurred()) SWIG_fail;
38784 }
38785 {
38786 resultobj = wxPyMake_wxObject(result, (bool)0);
38787 }
38788 {
38789 if (temp3)
38790 delete arg3;
38791 }
38792 {
38793 if (temp4)
38794 delete arg4;
38795 }
38796 return resultobj;
38797 fail:
38798 {
38799 if (temp3)
38800 delete arg3;
38801 }
38802 {
38803 if (temp4)
38804 delete arg4;
38805 }
38806 return NULL;
38807 }
38808
38809
38810 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38811 PyObject *resultobj = 0;
38812 wxMenu *arg1 = (wxMenu *) 0 ;
38813 int arg2 ;
38814 wxString *arg3 = 0 ;
38815 wxMenu *arg4 = (wxMenu *) 0 ;
38816 wxString const &arg5_defvalue = wxPyEmptyString ;
38817 wxString *arg5 = (wxString *) &arg5_defvalue ;
38818 wxMenuItem *result = 0 ;
38819 void *argp1 = 0 ;
38820 int res1 = 0 ;
38821 int val2 ;
38822 int ecode2 = 0 ;
38823 bool temp3 = false ;
38824 void *argp4 = 0 ;
38825 int res4 = 0 ;
38826 bool temp5 = false ;
38827 PyObject * obj0 = 0 ;
38828 PyObject * obj1 = 0 ;
38829 PyObject * obj2 = 0 ;
38830 PyObject * obj3 = 0 ;
38831 PyObject * obj4 = 0 ;
38832 char * kwnames[] = {
38833 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38834 };
38835
38836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38838 if (!SWIG_IsOK(res1)) {
38839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38840 }
38841 arg1 = reinterpret_cast< wxMenu * >(argp1);
38842 ecode2 = SWIG_AsVal_int(obj1, &val2);
38843 if (!SWIG_IsOK(ecode2)) {
38844 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
38845 }
38846 arg2 = static_cast< int >(val2);
38847 {
38848 arg3 = wxString_in_helper(obj2);
38849 if (arg3 == NULL) SWIG_fail;
38850 temp3 = true;
38851 }
38852 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
38853 if (!SWIG_IsOK(res4)) {
38854 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
38855 }
38856 arg4 = reinterpret_cast< wxMenu * >(argp4);
38857 if (obj4) {
38858 {
38859 arg5 = wxString_in_helper(obj4);
38860 if (arg5 == NULL) SWIG_fail;
38861 temp5 = true;
38862 }
38863 }
38864 {
38865 PyThreadState* __tstate = wxPyBeginAllowThreads();
38866 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
38867 wxPyEndAllowThreads(__tstate);
38868 if (PyErr_Occurred()) SWIG_fail;
38869 }
38870 {
38871 resultobj = wxPyMake_wxObject(result, (bool)0);
38872 }
38873 {
38874 if (temp3)
38875 delete arg3;
38876 }
38877 {
38878 if (temp5)
38879 delete arg5;
38880 }
38881 return resultobj;
38882 fail:
38883 {
38884 if (temp3)
38885 delete arg3;
38886 }
38887 {
38888 if (temp5)
38889 delete arg5;
38890 }
38891 return NULL;
38892 }
38893
38894
38895 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38896 PyObject *resultobj = 0;
38897 wxMenu *arg1 = (wxMenu *) 0 ;
38898 wxMenu *arg2 = (wxMenu *) 0 ;
38899 wxString *arg3 = 0 ;
38900 wxString const &arg4_defvalue = wxPyEmptyString ;
38901 wxString *arg4 = (wxString *) &arg4_defvalue ;
38902 wxMenuItem *result = 0 ;
38903 void *argp1 = 0 ;
38904 int res1 = 0 ;
38905 void *argp2 = 0 ;
38906 int res2 = 0 ;
38907 bool temp3 = false ;
38908 bool temp4 = false ;
38909 PyObject * obj0 = 0 ;
38910 PyObject * obj1 = 0 ;
38911 PyObject * obj2 = 0 ;
38912 PyObject * obj3 = 0 ;
38913 char * kwnames[] = {
38914 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
38915 };
38916
38917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38919 if (!SWIG_IsOK(res1)) {
38920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38921 }
38922 arg1 = reinterpret_cast< wxMenu * >(argp1);
38923 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
38924 if (!SWIG_IsOK(res2)) {
38925 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
38926 }
38927 arg2 = reinterpret_cast< wxMenu * >(argp2);
38928 {
38929 arg3 = wxString_in_helper(obj2);
38930 if (arg3 == NULL) SWIG_fail;
38931 temp3 = true;
38932 }
38933 if (obj3) {
38934 {
38935 arg4 = wxString_in_helper(obj3);
38936 if (arg4 == NULL) SWIG_fail;
38937 temp4 = true;
38938 }
38939 }
38940 {
38941 PyThreadState* __tstate = wxPyBeginAllowThreads();
38942 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38943 wxPyEndAllowThreads(__tstate);
38944 if (PyErr_Occurred()) SWIG_fail;
38945 }
38946 {
38947 resultobj = wxPyMake_wxObject(result, (bool)0);
38948 }
38949 {
38950 if (temp3)
38951 delete arg3;
38952 }
38953 {
38954 if (temp4)
38955 delete arg4;
38956 }
38957 return resultobj;
38958 fail:
38959 {
38960 if (temp3)
38961 delete arg3;
38962 }
38963 {
38964 if (temp4)
38965 delete arg4;
38966 }
38967 return NULL;
38968 }
38969
38970
38971 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38972 PyObject *resultobj = 0;
38973 wxMenu *arg1 = (wxMenu *) 0 ;
38974 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38975 wxMenuItem *result = 0 ;
38976 void *argp1 = 0 ;
38977 int res1 = 0 ;
38978 int res2 = 0 ;
38979 PyObject * obj0 = 0 ;
38980 PyObject * obj1 = 0 ;
38981 char * kwnames[] = {
38982 (char *) "self",(char *) "item", NULL
38983 };
38984
38985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
38986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38987 if (!SWIG_IsOK(res1)) {
38988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38989 }
38990 arg1 = reinterpret_cast< wxMenu * >(argp1);
38991 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38992 if (!SWIG_IsOK(res2)) {
38993 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38994 }
38995 {
38996 PyThreadState* __tstate = wxPyBeginAllowThreads();
38997 result = (wxMenuItem *)(arg1)->Append(arg2);
38998 wxPyEndAllowThreads(__tstate);
38999 if (PyErr_Occurred()) SWIG_fail;
39000 }
39001 {
39002 resultobj = wxPyMake_wxObject(result, (bool)0);
39003 }
39004 return resultobj;
39005 fail:
39006 return NULL;
39007 }
39008
39009
39010 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39011 PyObject *resultobj = 0;
39012 wxMenu *arg1 = (wxMenu *) 0 ;
39013 size_t arg2 ;
39014 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
39015 wxMenuItem *result = 0 ;
39016 void *argp1 = 0 ;
39017 int res1 = 0 ;
39018 size_t val2 ;
39019 int ecode2 = 0 ;
39020 int res3 = 0 ;
39021 PyObject * obj0 = 0 ;
39022 PyObject * obj1 = 0 ;
39023 PyObject * obj2 = 0 ;
39024 char * kwnames[] = {
39025 (char *) "self",(char *) "pos",(char *) "item", NULL
39026 };
39027
39028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39030 if (!SWIG_IsOK(res1)) {
39031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39032 }
39033 arg1 = reinterpret_cast< wxMenu * >(argp1);
39034 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39035 if (!SWIG_IsOK(ecode2)) {
39036 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
39037 }
39038 arg2 = static_cast< size_t >(val2);
39039 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39040 if (!SWIG_IsOK(res3)) {
39041 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
39042 }
39043 {
39044 PyThreadState* __tstate = wxPyBeginAllowThreads();
39045 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
39046 wxPyEndAllowThreads(__tstate);
39047 if (PyErr_Occurred()) SWIG_fail;
39048 }
39049 {
39050 resultobj = wxPyMake_wxObject(result, (bool)0);
39051 }
39052 return resultobj;
39053 fail:
39054 return NULL;
39055 }
39056
39057
39058 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39059 PyObject *resultobj = 0;
39060 wxMenu *arg1 = (wxMenu *) 0 ;
39061 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39062 wxMenuItem *result = 0 ;
39063 void *argp1 = 0 ;
39064 int res1 = 0 ;
39065 int res2 = 0 ;
39066 PyObject * obj0 = 0 ;
39067 PyObject * obj1 = 0 ;
39068 char * kwnames[] = {
39069 (char *) "self",(char *) "item", NULL
39070 };
39071
39072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
39073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39074 if (!SWIG_IsOK(res1)) {
39075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39076 }
39077 arg1 = reinterpret_cast< wxMenu * >(argp1);
39078 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39079 if (!SWIG_IsOK(res2)) {
39080 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39081 }
39082 {
39083 PyThreadState* __tstate = wxPyBeginAllowThreads();
39084 result = (wxMenuItem *)(arg1)->Prepend(arg2);
39085 wxPyEndAllowThreads(__tstate);
39086 if (PyErr_Occurred()) SWIG_fail;
39087 }
39088 {
39089 resultobj = wxPyMake_wxObject(result, (bool)0);
39090 }
39091 return resultobj;
39092 fail:
39093 return NULL;
39094 }
39095
39096
39097 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39098 PyObject *resultobj = 0;
39099 wxMenu *arg1 = (wxMenu *) 0 ;
39100 void *argp1 = 0 ;
39101 int res1 = 0 ;
39102 PyObject *swig_obj[1] ;
39103
39104 if (!args) SWIG_fail;
39105 swig_obj[0] = args;
39106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39107 if (!SWIG_IsOK(res1)) {
39108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
39109 }
39110 arg1 = reinterpret_cast< wxMenu * >(argp1);
39111 {
39112 PyThreadState* __tstate = wxPyBeginAllowThreads();
39113 (arg1)->Break();
39114 wxPyEndAllowThreads(__tstate);
39115 if (PyErr_Occurred()) SWIG_fail;
39116 }
39117 resultobj = SWIG_Py_Void();
39118 return resultobj;
39119 fail:
39120 return NULL;
39121 }
39122
39123
39124 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39125 PyObject *resultobj = 0;
39126 wxMenu *arg1 = (wxMenu *) 0 ;
39127 size_t arg2 ;
39128 int arg3 ;
39129 wxString *arg4 = 0 ;
39130 wxString const &arg5_defvalue = wxPyEmptyString ;
39131 wxString *arg5 = (wxString *) &arg5_defvalue ;
39132 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
39133 wxMenuItem *result = 0 ;
39134 void *argp1 = 0 ;
39135 int res1 = 0 ;
39136 size_t val2 ;
39137 int ecode2 = 0 ;
39138 int val3 ;
39139 int ecode3 = 0 ;
39140 bool temp4 = false ;
39141 bool temp5 = false ;
39142 int val6 ;
39143 int ecode6 = 0 ;
39144 PyObject * obj0 = 0 ;
39145 PyObject * obj1 = 0 ;
39146 PyObject * obj2 = 0 ;
39147 PyObject * obj3 = 0 ;
39148 PyObject * obj4 = 0 ;
39149 PyObject * obj5 = 0 ;
39150 char * kwnames[] = {
39151 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39152 };
39153
39154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39155 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39156 if (!SWIG_IsOK(res1)) {
39157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
39158 }
39159 arg1 = reinterpret_cast< wxMenu * >(argp1);
39160 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39161 if (!SWIG_IsOK(ecode2)) {
39162 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
39163 }
39164 arg2 = static_cast< size_t >(val2);
39165 ecode3 = SWIG_AsVal_int(obj2, &val3);
39166 if (!SWIG_IsOK(ecode3)) {
39167 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
39168 }
39169 arg3 = static_cast< int >(val3);
39170 {
39171 arg4 = wxString_in_helper(obj3);
39172 if (arg4 == NULL) SWIG_fail;
39173 temp4 = true;
39174 }
39175 if (obj4) {
39176 {
39177 arg5 = wxString_in_helper(obj4);
39178 if (arg5 == NULL) SWIG_fail;
39179 temp5 = true;
39180 }
39181 }
39182 if (obj5) {
39183 ecode6 = SWIG_AsVal_int(obj5, &val6);
39184 if (!SWIG_IsOK(ecode6)) {
39185 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
39186 }
39187 arg6 = static_cast< wxItemKind >(val6);
39188 }
39189 {
39190 PyThreadState* __tstate = wxPyBeginAllowThreads();
39191 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
39192 wxPyEndAllowThreads(__tstate);
39193 if (PyErr_Occurred()) SWIG_fail;
39194 }
39195 {
39196 resultobj = wxPyMake_wxObject(result, (bool)0);
39197 }
39198 {
39199 if (temp4)
39200 delete arg4;
39201 }
39202 {
39203 if (temp5)
39204 delete arg5;
39205 }
39206 return resultobj;
39207 fail:
39208 {
39209 if (temp4)
39210 delete arg4;
39211 }
39212 {
39213 if (temp5)
39214 delete arg5;
39215 }
39216 return NULL;
39217 }
39218
39219
39220 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39221 PyObject *resultobj = 0;
39222 wxMenu *arg1 = (wxMenu *) 0 ;
39223 size_t arg2 ;
39224 wxMenuItem *result = 0 ;
39225 void *argp1 = 0 ;
39226 int res1 = 0 ;
39227 size_t val2 ;
39228 int ecode2 = 0 ;
39229 PyObject * obj0 = 0 ;
39230 PyObject * obj1 = 0 ;
39231 char * kwnames[] = {
39232 (char *) "self",(char *) "pos", NULL
39233 };
39234
39235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
39236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39237 if (!SWIG_IsOK(res1)) {
39238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39239 }
39240 arg1 = reinterpret_cast< wxMenu * >(argp1);
39241 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39242 if (!SWIG_IsOK(ecode2)) {
39243 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
39244 }
39245 arg2 = static_cast< size_t >(val2);
39246 {
39247 PyThreadState* __tstate = wxPyBeginAllowThreads();
39248 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
39249 wxPyEndAllowThreads(__tstate);
39250 if (PyErr_Occurred()) SWIG_fail;
39251 }
39252 {
39253 resultobj = wxPyMake_wxObject(result, (bool)0);
39254 }
39255 return resultobj;
39256 fail:
39257 return NULL;
39258 }
39259
39260
39261 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39262 PyObject *resultobj = 0;
39263 wxMenu *arg1 = (wxMenu *) 0 ;
39264 size_t arg2 ;
39265 int arg3 ;
39266 wxString *arg4 = 0 ;
39267 wxString const &arg5_defvalue = wxPyEmptyString ;
39268 wxString *arg5 = (wxString *) &arg5_defvalue ;
39269 wxMenuItem *result = 0 ;
39270 void *argp1 = 0 ;
39271 int res1 = 0 ;
39272 size_t val2 ;
39273 int ecode2 = 0 ;
39274 int val3 ;
39275 int ecode3 = 0 ;
39276 bool temp4 = false ;
39277 bool temp5 = false ;
39278 PyObject * obj0 = 0 ;
39279 PyObject * obj1 = 0 ;
39280 PyObject * obj2 = 0 ;
39281 PyObject * obj3 = 0 ;
39282 PyObject * obj4 = 0 ;
39283 char * kwnames[] = {
39284 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39285 };
39286
39287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39289 if (!SWIG_IsOK(res1)) {
39290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39291 }
39292 arg1 = reinterpret_cast< wxMenu * >(argp1);
39293 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39294 if (!SWIG_IsOK(ecode2)) {
39295 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
39296 }
39297 arg2 = static_cast< size_t >(val2);
39298 ecode3 = SWIG_AsVal_int(obj2, &val3);
39299 if (!SWIG_IsOK(ecode3)) {
39300 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
39301 }
39302 arg3 = static_cast< int >(val3);
39303 {
39304 arg4 = wxString_in_helper(obj3);
39305 if (arg4 == NULL) SWIG_fail;
39306 temp4 = true;
39307 }
39308 if (obj4) {
39309 {
39310 arg5 = wxString_in_helper(obj4);
39311 if (arg5 == NULL) SWIG_fail;
39312 temp5 = true;
39313 }
39314 }
39315 {
39316 PyThreadState* __tstate = wxPyBeginAllowThreads();
39317 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39318 wxPyEndAllowThreads(__tstate);
39319 if (PyErr_Occurred()) SWIG_fail;
39320 }
39321 {
39322 resultobj = wxPyMake_wxObject(result, (bool)0);
39323 }
39324 {
39325 if (temp4)
39326 delete arg4;
39327 }
39328 {
39329 if (temp5)
39330 delete arg5;
39331 }
39332 return resultobj;
39333 fail:
39334 {
39335 if (temp4)
39336 delete arg4;
39337 }
39338 {
39339 if (temp5)
39340 delete arg5;
39341 }
39342 return NULL;
39343 }
39344
39345
39346 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39347 PyObject *resultobj = 0;
39348 wxMenu *arg1 = (wxMenu *) 0 ;
39349 size_t arg2 ;
39350 int arg3 ;
39351 wxString *arg4 = 0 ;
39352 wxString const &arg5_defvalue = wxPyEmptyString ;
39353 wxString *arg5 = (wxString *) &arg5_defvalue ;
39354 wxMenuItem *result = 0 ;
39355 void *argp1 = 0 ;
39356 int res1 = 0 ;
39357 size_t val2 ;
39358 int ecode2 = 0 ;
39359 int val3 ;
39360 int ecode3 = 0 ;
39361 bool temp4 = false ;
39362 bool temp5 = false ;
39363 PyObject * obj0 = 0 ;
39364 PyObject * obj1 = 0 ;
39365 PyObject * obj2 = 0 ;
39366 PyObject * obj3 = 0 ;
39367 PyObject * obj4 = 0 ;
39368 char * kwnames[] = {
39369 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39370 };
39371
39372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39374 if (!SWIG_IsOK(res1)) {
39375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39376 }
39377 arg1 = reinterpret_cast< wxMenu * >(argp1);
39378 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39379 if (!SWIG_IsOK(ecode2)) {
39380 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
39381 }
39382 arg2 = static_cast< size_t >(val2);
39383 ecode3 = SWIG_AsVal_int(obj2, &val3);
39384 if (!SWIG_IsOK(ecode3)) {
39385 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
39386 }
39387 arg3 = static_cast< int >(val3);
39388 {
39389 arg4 = wxString_in_helper(obj3);
39390 if (arg4 == NULL) SWIG_fail;
39391 temp4 = true;
39392 }
39393 if (obj4) {
39394 {
39395 arg5 = wxString_in_helper(obj4);
39396 if (arg5 == NULL) SWIG_fail;
39397 temp5 = true;
39398 }
39399 }
39400 {
39401 PyThreadState* __tstate = wxPyBeginAllowThreads();
39402 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39403 wxPyEndAllowThreads(__tstate);
39404 if (PyErr_Occurred()) SWIG_fail;
39405 }
39406 {
39407 resultobj = wxPyMake_wxObject(result, (bool)0);
39408 }
39409 {
39410 if (temp4)
39411 delete arg4;
39412 }
39413 {
39414 if (temp5)
39415 delete arg5;
39416 }
39417 return resultobj;
39418 fail:
39419 {
39420 if (temp4)
39421 delete arg4;
39422 }
39423 {
39424 if (temp5)
39425 delete arg5;
39426 }
39427 return NULL;
39428 }
39429
39430
39431 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39432 PyObject *resultobj = 0;
39433 wxMenu *arg1 = (wxMenu *) 0 ;
39434 size_t arg2 ;
39435 int arg3 ;
39436 wxString *arg4 = 0 ;
39437 wxMenu *arg5 = (wxMenu *) 0 ;
39438 wxString const &arg6_defvalue = wxPyEmptyString ;
39439 wxString *arg6 = (wxString *) &arg6_defvalue ;
39440 wxMenuItem *result = 0 ;
39441 void *argp1 = 0 ;
39442 int res1 = 0 ;
39443 size_t val2 ;
39444 int ecode2 = 0 ;
39445 int val3 ;
39446 int ecode3 = 0 ;
39447 bool temp4 = false ;
39448 void *argp5 = 0 ;
39449 int res5 = 0 ;
39450 bool temp6 = false ;
39451 PyObject * obj0 = 0 ;
39452 PyObject * obj1 = 0 ;
39453 PyObject * obj2 = 0 ;
39454 PyObject * obj3 = 0 ;
39455 PyObject * obj4 = 0 ;
39456 PyObject * obj5 = 0 ;
39457 char * kwnames[] = {
39458 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39459 };
39460
39461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39463 if (!SWIG_IsOK(res1)) {
39464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39465 }
39466 arg1 = reinterpret_cast< wxMenu * >(argp1);
39467 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39468 if (!SWIG_IsOK(ecode2)) {
39469 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
39470 }
39471 arg2 = static_cast< size_t >(val2);
39472 ecode3 = SWIG_AsVal_int(obj2, &val3);
39473 if (!SWIG_IsOK(ecode3)) {
39474 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
39475 }
39476 arg3 = static_cast< int >(val3);
39477 {
39478 arg4 = wxString_in_helper(obj3);
39479 if (arg4 == NULL) SWIG_fail;
39480 temp4 = true;
39481 }
39482 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
39483 if (!SWIG_IsOK(res5)) {
39484 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
39485 }
39486 arg5 = reinterpret_cast< wxMenu * >(argp5);
39487 if (obj5) {
39488 {
39489 arg6 = wxString_in_helper(obj5);
39490 if (arg6 == NULL) SWIG_fail;
39491 temp6 = true;
39492 }
39493 }
39494 {
39495 PyThreadState* __tstate = wxPyBeginAllowThreads();
39496 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
39497 wxPyEndAllowThreads(__tstate);
39498 if (PyErr_Occurred()) SWIG_fail;
39499 }
39500 {
39501 resultobj = wxPyMake_wxObject(result, (bool)0);
39502 }
39503 {
39504 if (temp4)
39505 delete arg4;
39506 }
39507 {
39508 if (temp6)
39509 delete arg6;
39510 }
39511 return resultobj;
39512 fail:
39513 {
39514 if (temp4)
39515 delete arg4;
39516 }
39517 {
39518 if (temp6)
39519 delete arg6;
39520 }
39521 return NULL;
39522 }
39523
39524
39525 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39526 PyObject *resultobj = 0;
39527 wxMenu *arg1 = (wxMenu *) 0 ;
39528 int arg2 ;
39529 wxString *arg3 = 0 ;
39530 wxString const &arg4_defvalue = wxPyEmptyString ;
39531 wxString *arg4 = (wxString *) &arg4_defvalue ;
39532 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39533 wxMenuItem *result = 0 ;
39534 void *argp1 = 0 ;
39535 int res1 = 0 ;
39536 int val2 ;
39537 int ecode2 = 0 ;
39538 bool temp3 = false ;
39539 bool temp4 = false ;
39540 int val5 ;
39541 int ecode5 = 0 ;
39542 PyObject * obj0 = 0 ;
39543 PyObject * obj1 = 0 ;
39544 PyObject * obj2 = 0 ;
39545 PyObject * obj3 = 0 ;
39546 PyObject * obj4 = 0 ;
39547 char * kwnames[] = {
39548 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39549 };
39550
39551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) 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_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
39555 }
39556 arg1 = reinterpret_cast< wxMenu * >(argp1);
39557 ecode2 = SWIG_AsVal_int(obj1, &val2);
39558 if (!SWIG_IsOK(ecode2)) {
39559 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
39560 }
39561 arg2 = static_cast< int >(val2);
39562 {
39563 arg3 = wxString_in_helper(obj2);
39564 if (arg3 == NULL) SWIG_fail;
39565 temp3 = true;
39566 }
39567 if (obj3) {
39568 {
39569 arg4 = wxString_in_helper(obj3);
39570 if (arg4 == NULL) SWIG_fail;
39571 temp4 = true;
39572 }
39573 }
39574 if (obj4) {
39575 ecode5 = SWIG_AsVal_int(obj4, &val5);
39576 if (!SWIG_IsOK(ecode5)) {
39577 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
39578 }
39579 arg5 = static_cast< wxItemKind >(val5);
39580 }
39581 {
39582 PyThreadState* __tstate = wxPyBeginAllowThreads();
39583 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39584 wxPyEndAllowThreads(__tstate);
39585 if (PyErr_Occurred()) SWIG_fail;
39586 }
39587 {
39588 resultobj = wxPyMake_wxObject(result, (bool)0);
39589 }
39590 {
39591 if (temp3)
39592 delete arg3;
39593 }
39594 {
39595 if (temp4)
39596 delete arg4;
39597 }
39598 return resultobj;
39599 fail:
39600 {
39601 if (temp3)
39602 delete arg3;
39603 }
39604 {
39605 if (temp4)
39606 delete arg4;
39607 }
39608 return NULL;
39609 }
39610
39611
39612 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39613 PyObject *resultobj = 0;
39614 wxMenu *arg1 = (wxMenu *) 0 ;
39615 wxMenuItem *result = 0 ;
39616 void *argp1 = 0 ;
39617 int res1 = 0 ;
39618 PyObject *swig_obj[1] ;
39619
39620 if (!args) SWIG_fail;
39621 swig_obj[0] = args;
39622 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39623 if (!SWIG_IsOK(res1)) {
39624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39625 }
39626 arg1 = reinterpret_cast< wxMenu * >(argp1);
39627 {
39628 PyThreadState* __tstate = wxPyBeginAllowThreads();
39629 result = (wxMenuItem *)(arg1)->PrependSeparator();
39630 wxPyEndAllowThreads(__tstate);
39631 if (PyErr_Occurred()) SWIG_fail;
39632 }
39633 {
39634 resultobj = wxPyMake_wxObject(result, (bool)0);
39635 }
39636 return resultobj;
39637 fail:
39638 return NULL;
39639 }
39640
39641
39642 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39643 PyObject *resultobj = 0;
39644 wxMenu *arg1 = (wxMenu *) 0 ;
39645 int arg2 ;
39646 wxString *arg3 = 0 ;
39647 wxString const &arg4_defvalue = wxPyEmptyString ;
39648 wxString *arg4 = (wxString *) &arg4_defvalue ;
39649 wxMenuItem *result = 0 ;
39650 void *argp1 = 0 ;
39651 int res1 = 0 ;
39652 int val2 ;
39653 int ecode2 = 0 ;
39654 bool temp3 = false ;
39655 bool temp4 = false ;
39656 PyObject * obj0 = 0 ;
39657 PyObject * obj1 = 0 ;
39658 PyObject * obj2 = 0 ;
39659 PyObject * obj3 = 0 ;
39660 char * kwnames[] = {
39661 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39662 };
39663
39664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39666 if (!SWIG_IsOK(res1)) {
39667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39668 }
39669 arg1 = reinterpret_cast< wxMenu * >(argp1);
39670 ecode2 = SWIG_AsVal_int(obj1, &val2);
39671 if (!SWIG_IsOK(ecode2)) {
39672 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
39673 }
39674 arg2 = static_cast< int >(val2);
39675 {
39676 arg3 = wxString_in_helper(obj2);
39677 if (arg3 == NULL) SWIG_fail;
39678 temp3 = true;
39679 }
39680 if (obj3) {
39681 {
39682 arg4 = wxString_in_helper(obj3);
39683 if (arg4 == NULL) SWIG_fail;
39684 temp4 = true;
39685 }
39686 }
39687 {
39688 PyThreadState* __tstate = wxPyBeginAllowThreads();
39689 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39690 wxPyEndAllowThreads(__tstate);
39691 if (PyErr_Occurred()) SWIG_fail;
39692 }
39693 {
39694 resultobj = wxPyMake_wxObject(result, (bool)0);
39695 }
39696 {
39697 if (temp3)
39698 delete arg3;
39699 }
39700 {
39701 if (temp4)
39702 delete arg4;
39703 }
39704 return resultobj;
39705 fail:
39706 {
39707 if (temp3)
39708 delete arg3;
39709 }
39710 {
39711 if (temp4)
39712 delete arg4;
39713 }
39714 return NULL;
39715 }
39716
39717
39718 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39719 PyObject *resultobj = 0;
39720 wxMenu *arg1 = (wxMenu *) 0 ;
39721 int arg2 ;
39722 wxString *arg3 = 0 ;
39723 wxString const &arg4_defvalue = wxPyEmptyString ;
39724 wxString *arg4 = (wxString *) &arg4_defvalue ;
39725 wxMenuItem *result = 0 ;
39726 void *argp1 = 0 ;
39727 int res1 = 0 ;
39728 int val2 ;
39729 int ecode2 = 0 ;
39730 bool temp3 = false ;
39731 bool temp4 = false ;
39732 PyObject * obj0 = 0 ;
39733 PyObject * obj1 = 0 ;
39734 PyObject * obj2 = 0 ;
39735 PyObject * obj3 = 0 ;
39736 char * kwnames[] = {
39737 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39738 };
39739
39740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39742 if (!SWIG_IsOK(res1)) {
39743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39744 }
39745 arg1 = reinterpret_cast< wxMenu * >(argp1);
39746 ecode2 = SWIG_AsVal_int(obj1, &val2);
39747 if (!SWIG_IsOK(ecode2)) {
39748 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
39749 }
39750 arg2 = static_cast< int >(val2);
39751 {
39752 arg3 = wxString_in_helper(obj2);
39753 if (arg3 == NULL) SWIG_fail;
39754 temp3 = true;
39755 }
39756 if (obj3) {
39757 {
39758 arg4 = wxString_in_helper(obj3);
39759 if (arg4 == NULL) SWIG_fail;
39760 temp4 = true;
39761 }
39762 }
39763 {
39764 PyThreadState* __tstate = wxPyBeginAllowThreads();
39765 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39766 wxPyEndAllowThreads(__tstate);
39767 if (PyErr_Occurred()) SWIG_fail;
39768 }
39769 {
39770 resultobj = wxPyMake_wxObject(result, (bool)0);
39771 }
39772 {
39773 if (temp3)
39774 delete arg3;
39775 }
39776 {
39777 if (temp4)
39778 delete arg4;
39779 }
39780 return resultobj;
39781 fail:
39782 {
39783 if (temp3)
39784 delete arg3;
39785 }
39786 {
39787 if (temp4)
39788 delete arg4;
39789 }
39790 return NULL;
39791 }
39792
39793
39794 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39795 PyObject *resultobj = 0;
39796 wxMenu *arg1 = (wxMenu *) 0 ;
39797 int arg2 ;
39798 wxString *arg3 = 0 ;
39799 wxMenu *arg4 = (wxMenu *) 0 ;
39800 wxString const &arg5_defvalue = wxPyEmptyString ;
39801 wxString *arg5 = (wxString *) &arg5_defvalue ;
39802 wxMenuItem *result = 0 ;
39803 void *argp1 = 0 ;
39804 int res1 = 0 ;
39805 int val2 ;
39806 int ecode2 = 0 ;
39807 bool temp3 = false ;
39808 void *argp4 = 0 ;
39809 int res4 = 0 ;
39810 bool temp5 = false ;
39811 PyObject * obj0 = 0 ;
39812 PyObject * obj1 = 0 ;
39813 PyObject * obj2 = 0 ;
39814 PyObject * obj3 = 0 ;
39815 PyObject * obj4 = 0 ;
39816 char * kwnames[] = {
39817 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39818 };
39819
39820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39822 if (!SWIG_IsOK(res1)) {
39823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39824 }
39825 arg1 = reinterpret_cast< wxMenu * >(argp1);
39826 ecode2 = SWIG_AsVal_int(obj1, &val2);
39827 if (!SWIG_IsOK(ecode2)) {
39828 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
39829 }
39830 arg2 = static_cast< int >(val2);
39831 {
39832 arg3 = wxString_in_helper(obj2);
39833 if (arg3 == NULL) SWIG_fail;
39834 temp3 = true;
39835 }
39836 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39837 if (!SWIG_IsOK(res4)) {
39838 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39839 }
39840 arg4 = reinterpret_cast< wxMenu * >(argp4);
39841 if (obj4) {
39842 {
39843 arg5 = wxString_in_helper(obj4);
39844 if (arg5 == NULL) SWIG_fail;
39845 temp5 = true;
39846 }
39847 }
39848 {
39849 PyThreadState* __tstate = wxPyBeginAllowThreads();
39850 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39851 wxPyEndAllowThreads(__tstate);
39852 if (PyErr_Occurred()) SWIG_fail;
39853 }
39854 {
39855 resultobj = wxPyMake_wxObject(result, (bool)0);
39856 }
39857 {
39858 if (temp3)
39859 delete arg3;
39860 }
39861 {
39862 if (temp5)
39863 delete arg5;
39864 }
39865 return resultobj;
39866 fail:
39867 {
39868 if (temp3)
39869 delete arg3;
39870 }
39871 {
39872 if (temp5)
39873 delete arg5;
39874 }
39875 return NULL;
39876 }
39877
39878
39879 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39880 PyObject *resultobj = 0;
39881 wxMenu *arg1 = (wxMenu *) 0 ;
39882 int arg2 ;
39883 wxMenuItem *result = 0 ;
39884 void *argp1 = 0 ;
39885 int res1 = 0 ;
39886 int val2 ;
39887 int ecode2 = 0 ;
39888 PyObject * obj0 = 0 ;
39889 PyObject * obj1 = 0 ;
39890 char * kwnames[] = {
39891 (char *) "self",(char *) "id", NULL
39892 };
39893
39894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
39895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39896 if (!SWIG_IsOK(res1)) {
39897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
39898 }
39899 arg1 = reinterpret_cast< wxMenu * >(argp1);
39900 ecode2 = SWIG_AsVal_int(obj1, &val2);
39901 if (!SWIG_IsOK(ecode2)) {
39902 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
39903 }
39904 arg2 = static_cast< int >(val2);
39905 {
39906 PyThreadState* __tstate = wxPyBeginAllowThreads();
39907 result = (wxMenuItem *)(arg1)->Remove(arg2);
39908 wxPyEndAllowThreads(__tstate);
39909 if (PyErr_Occurred()) SWIG_fail;
39910 }
39911 {
39912 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39913 }
39914 return resultobj;
39915 fail:
39916 return NULL;
39917 }
39918
39919
39920 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39921 PyObject *resultobj = 0;
39922 wxMenu *arg1 = (wxMenu *) 0 ;
39923 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39924 wxMenuItem *result = 0 ;
39925 void *argp1 = 0 ;
39926 int res1 = 0 ;
39927 void *argp2 = 0 ;
39928 int res2 = 0 ;
39929 PyObject * obj0 = 0 ;
39930 PyObject * obj1 = 0 ;
39931 char * kwnames[] = {
39932 (char *) "self",(char *) "item", NULL
39933 };
39934
39935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
39936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39937 if (!SWIG_IsOK(res1)) {
39938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39939 }
39940 arg1 = reinterpret_cast< wxMenu * >(argp1);
39941 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39942 if (!SWIG_IsOK(res2)) {
39943 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39944 }
39945 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39946 {
39947 PyThreadState* __tstate = wxPyBeginAllowThreads();
39948 result = (wxMenuItem *)(arg1)->Remove(arg2);
39949 wxPyEndAllowThreads(__tstate);
39950 if (PyErr_Occurred()) SWIG_fail;
39951 }
39952 {
39953 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39954 }
39955 return resultobj;
39956 fail:
39957 return NULL;
39958 }
39959
39960
39961 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39962 PyObject *resultobj = 0;
39963 wxMenu *arg1 = (wxMenu *) 0 ;
39964 int arg2 ;
39965 bool result;
39966 void *argp1 = 0 ;
39967 int res1 = 0 ;
39968 int val2 ;
39969 int ecode2 = 0 ;
39970 PyObject * obj0 = 0 ;
39971 PyObject * obj1 = 0 ;
39972 char * kwnames[] = {
39973 (char *) "self",(char *) "id", NULL
39974 };
39975
39976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
39977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39978 if (!SWIG_IsOK(res1)) {
39979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
39980 }
39981 arg1 = reinterpret_cast< wxMenu * >(argp1);
39982 ecode2 = SWIG_AsVal_int(obj1, &val2);
39983 if (!SWIG_IsOK(ecode2)) {
39984 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
39985 }
39986 arg2 = static_cast< int >(val2);
39987 {
39988 PyThreadState* __tstate = wxPyBeginAllowThreads();
39989 result = (bool)(arg1)->Delete(arg2);
39990 wxPyEndAllowThreads(__tstate);
39991 if (PyErr_Occurred()) SWIG_fail;
39992 }
39993 {
39994 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39995 }
39996 return resultobj;
39997 fail:
39998 return NULL;
39999 }
40000
40001
40002 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40003 PyObject *resultobj = 0;
40004 wxMenu *arg1 = (wxMenu *) 0 ;
40005 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40006 bool result;
40007 void *argp1 = 0 ;
40008 int res1 = 0 ;
40009 void *argp2 = 0 ;
40010 int res2 = 0 ;
40011 PyObject * obj0 = 0 ;
40012 PyObject * obj1 = 0 ;
40013 char * kwnames[] = {
40014 (char *) "self",(char *) "item", NULL
40015 };
40016
40017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
40018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40019 if (!SWIG_IsOK(res1)) {
40020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40021 }
40022 arg1 = reinterpret_cast< wxMenu * >(argp1);
40023 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
40024 if (!SWIG_IsOK(res2)) {
40025 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40026 }
40027 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
40028 {
40029 PyThreadState* __tstate = wxPyBeginAllowThreads();
40030 result = (bool)(arg1)->Delete(arg2);
40031 wxPyEndAllowThreads(__tstate);
40032 if (PyErr_Occurred()) SWIG_fail;
40033 }
40034 {
40035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40036 }
40037 return resultobj;
40038 fail:
40039 return NULL;
40040 }
40041
40042
40043 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40044 PyObject *resultobj = 0;
40045 wxMenu *arg1 = (wxMenu *) 0 ;
40046 void *argp1 = 0 ;
40047 int res1 = 0 ;
40048 PyObject *swig_obj[1] ;
40049
40050 if (!args) SWIG_fail;
40051 swig_obj[0] = args;
40052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40053 if (!SWIG_IsOK(res1)) {
40054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
40055 }
40056 arg1 = reinterpret_cast< wxMenu * >(argp1);
40057 {
40058 PyThreadState* __tstate = wxPyBeginAllowThreads();
40059 wxMenu_Destroy(arg1);
40060 wxPyEndAllowThreads(__tstate);
40061 if (PyErr_Occurred()) SWIG_fail;
40062 }
40063 resultobj = SWIG_Py_Void();
40064 return resultobj;
40065 fail:
40066 return NULL;
40067 }
40068
40069
40070 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40071 PyObject *resultobj = 0;
40072 wxMenu *arg1 = (wxMenu *) 0 ;
40073 int arg2 ;
40074 bool result;
40075 void *argp1 = 0 ;
40076 int res1 = 0 ;
40077 int val2 ;
40078 int ecode2 = 0 ;
40079 PyObject * obj0 = 0 ;
40080 PyObject * obj1 = 0 ;
40081 char * kwnames[] = {
40082 (char *) "self",(char *) "id", NULL
40083 };
40084
40085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
40086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40087 if (!SWIG_IsOK(res1)) {
40088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
40089 }
40090 arg1 = reinterpret_cast< wxMenu * >(argp1);
40091 ecode2 = SWIG_AsVal_int(obj1, &val2);
40092 if (!SWIG_IsOK(ecode2)) {
40093 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
40094 }
40095 arg2 = static_cast< int >(val2);
40096 {
40097 PyThreadState* __tstate = wxPyBeginAllowThreads();
40098 result = (bool)(arg1)->Destroy(arg2);
40099 wxPyEndAllowThreads(__tstate);
40100 if (PyErr_Occurred()) SWIG_fail;
40101 }
40102 {
40103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40104 }
40105 return resultobj;
40106 fail:
40107 return NULL;
40108 }
40109
40110
40111 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40112 PyObject *resultobj = 0;
40113 wxMenu *arg1 = (wxMenu *) 0 ;
40114 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40115 bool result;
40116 void *argp1 = 0 ;
40117 int res1 = 0 ;
40118 void *argp2 = 0 ;
40119 int res2 = 0 ;
40120 PyObject * obj0 = 0 ;
40121 PyObject * obj1 = 0 ;
40122 char * kwnames[] = {
40123 (char *) "self",(char *) "item", NULL
40124 };
40125
40126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
40127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40128 if (!SWIG_IsOK(res1)) {
40129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40130 }
40131 arg1 = reinterpret_cast< wxMenu * >(argp1);
40132 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
40133 if (!SWIG_IsOK(res2)) {
40134 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40135 }
40136 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
40137 {
40138 PyThreadState* __tstate = wxPyBeginAllowThreads();
40139 result = (bool)(arg1)->Destroy(arg2);
40140 wxPyEndAllowThreads(__tstate);
40141 if (PyErr_Occurred()) SWIG_fail;
40142 }
40143 {
40144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40145 }
40146 return resultobj;
40147 fail:
40148 return NULL;
40149 }
40150
40151
40152 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40153 PyObject *resultobj = 0;
40154 wxMenu *arg1 = (wxMenu *) 0 ;
40155 size_t result;
40156 void *argp1 = 0 ;
40157 int res1 = 0 ;
40158 PyObject *swig_obj[1] ;
40159
40160 if (!args) SWIG_fail;
40161 swig_obj[0] = args;
40162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40163 if (!SWIG_IsOK(res1)) {
40164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
40165 }
40166 arg1 = reinterpret_cast< wxMenu * >(argp1);
40167 {
40168 PyThreadState* __tstate = wxPyBeginAllowThreads();
40169 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
40170 wxPyEndAllowThreads(__tstate);
40171 if (PyErr_Occurred()) SWIG_fail;
40172 }
40173 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
40174 return resultobj;
40175 fail:
40176 return NULL;
40177 }
40178
40179
40180 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40181 PyObject *resultobj = 0;
40182 wxMenu *arg1 = (wxMenu *) 0 ;
40183 PyObject *result = 0 ;
40184 void *argp1 = 0 ;
40185 int res1 = 0 ;
40186 PyObject *swig_obj[1] ;
40187
40188 if (!args) SWIG_fail;
40189 swig_obj[0] = args;
40190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40191 if (!SWIG_IsOK(res1)) {
40192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
40193 }
40194 arg1 = reinterpret_cast< wxMenu * >(argp1);
40195 {
40196 PyThreadState* __tstate = wxPyBeginAllowThreads();
40197 result = (PyObject *)wxMenu_GetMenuItems(arg1);
40198 wxPyEndAllowThreads(__tstate);
40199 if (PyErr_Occurred()) SWIG_fail;
40200 }
40201 resultobj = result;
40202 return resultobj;
40203 fail:
40204 return NULL;
40205 }
40206
40207
40208 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40209 PyObject *resultobj = 0;
40210 wxMenu *arg1 = (wxMenu *) 0 ;
40211 wxString *arg2 = 0 ;
40212 int result;
40213 void *argp1 = 0 ;
40214 int res1 = 0 ;
40215 bool temp2 = false ;
40216 PyObject * obj0 = 0 ;
40217 PyObject * obj1 = 0 ;
40218 char * kwnames[] = {
40219 (char *) "self",(char *) "item", NULL
40220 };
40221
40222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
40223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40224 if (!SWIG_IsOK(res1)) {
40225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
40226 }
40227 arg1 = reinterpret_cast< wxMenu * >(argp1);
40228 {
40229 arg2 = wxString_in_helper(obj1);
40230 if (arg2 == NULL) SWIG_fail;
40231 temp2 = true;
40232 }
40233 {
40234 PyThreadState* __tstate = wxPyBeginAllowThreads();
40235 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
40236 wxPyEndAllowThreads(__tstate);
40237 if (PyErr_Occurred()) SWIG_fail;
40238 }
40239 resultobj = SWIG_From_int(static_cast< int >(result));
40240 {
40241 if (temp2)
40242 delete arg2;
40243 }
40244 return resultobj;
40245 fail:
40246 {
40247 if (temp2)
40248 delete arg2;
40249 }
40250 return NULL;
40251 }
40252
40253
40254 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40255 PyObject *resultobj = 0;
40256 wxMenu *arg1 = (wxMenu *) 0 ;
40257 int arg2 ;
40258 wxMenuItem *result = 0 ;
40259 void *argp1 = 0 ;
40260 int res1 = 0 ;
40261 int val2 ;
40262 int ecode2 = 0 ;
40263 PyObject * obj0 = 0 ;
40264 PyObject * obj1 = 0 ;
40265 char * kwnames[] = {
40266 (char *) "self",(char *) "id", NULL
40267 };
40268
40269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
40270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40271 if (!SWIG_IsOK(res1)) {
40272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
40273 }
40274 arg1 = reinterpret_cast< wxMenu * >(argp1);
40275 ecode2 = SWIG_AsVal_int(obj1, &val2);
40276 if (!SWIG_IsOK(ecode2)) {
40277 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
40278 }
40279 arg2 = static_cast< int >(val2);
40280 {
40281 PyThreadState* __tstate = wxPyBeginAllowThreads();
40282 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
40283 wxPyEndAllowThreads(__tstate);
40284 if (PyErr_Occurred()) SWIG_fail;
40285 }
40286 {
40287 resultobj = wxPyMake_wxObject(result, (bool)0);
40288 }
40289 return resultobj;
40290 fail:
40291 return NULL;
40292 }
40293
40294
40295 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40296 PyObject *resultobj = 0;
40297 wxMenu *arg1 = (wxMenu *) 0 ;
40298 size_t arg2 ;
40299 wxMenuItem *result = 0 ;
40300 void *argp1 = 0 ;
40301 int res1 = 0 ;
40302 size_t val2 ;
40303 int ecode2 = 0 ;
40304 PyObject * obj0 = 0 ;
40305 PyObject * obj1 = 0 ;
40306 char * kwnames[] = {
40307 (char *) "self",(char *) "position", NULL
40308 };
40309
40310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
40311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40312 if (!SWIG_IsOK(res1)) {
40313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
40314 }
40315 arg1 = reinterpret_cast< wxMenu * >(argp1);
40316 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40317 if (!SWIG_IsOK(ecode2)) {
40318 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
40319 }
40320 arg2 = static_cast< size_t >(val2);
40321 {
40322 PyThreadState* __tstate = wxPyBeginAllowThreads();
40323 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
40324 wxPyEndAllowThreads(__tstate);
40325 if (PyErr_Occurred()) SWIG_fail;
40326 }
40327 {
40328 resultobj = wxPyMake_wxObject(result, (bool)0);
40329 }
40330 return resultobj;
40331 fail:
40332 return NULL;
40333 }
40334
40335
40336 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40337 PyObject *resultobj = 0;
40338 wxMenu *arg1 = (wxMenu *) 0 ;
40339 int arg2 ;
40340 bool arg3 ;
40341 void *argp1 = 0 ;
40342 int res1 = 0 ;
40343 int val2 ;
40344 int ecode2 = 0 ;
40345 bool val3 ;
40346 int ecode3 = 0 ;
40347 PyObject * obj0 = 0 ;
40348 PyObject * obj1 = 0 ;
40349 PyObject * obj2 = 0 ;
40350 char * kwnames[] = {
40351 (char *) "self",(char *) "id",(char *) "enable", NULL
40352 };
40353
40354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40356 if (!SWIG_IsOK(res1)) {
40357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
40358 }
40359 arg1 = reinterpret_cast< wxMenu * >(argp1);
40360 ecode2 = SWIG_AsVal_int(obj1, &val2);
40361 if (!SWIG_IsOK(ecode2)) {
40362 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
40363 }
40364 arg2 = static_cast< int >(val2);
40365 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40366 if (!SWIG_IsOK(ecode3)) {
40367 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
40368 }
40369 arg3 = static_cast< bool >(val3);
40370 {
40371 PyThreadState* __tstate = wxPyBeginAllowThreads();
40372 (arg1)->Enable(arg2,arg3);
40373 wxPyEndAllowThreads(__tstate);
40374 if (PyErr_Occurred()) SWIG_fail;
40375 }
40376 resultobj = SWIG_Py_Void();
40377 return resultobj;
40378 fail:
40379 return NULL;
40380 }
40381
40382
40383 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40384 PyObject *resultobj = 0;
40385 wxMenu *arg1 = (wxMenu *) 0 ;
40386 int arg2 ;
40387 bool result;
40388 void *argp1 = 0 ;
40389 int res1 = 0 ;
40390 int val2 ;
40391 int ecode2 = 0 ;
40392 PyObject * obj0 = 0 ;
40393 PyObject * obj1 = 0 ;
40394 char * kwnames[] = {
40395 (char *) "self",(char *) "id", NULL
40396 };
40397
40398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
40399 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40400 if (!SWIG_IsOK(res1)) {
40401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
40402 }
40403 arg1 = reinterpret_cast< wxMenu * >(argp1);
40404 ecode2 = SWIG_AsVal_int(obj1, &val2);
40405 if (!SWIG_IsOK(ecode2)) {
40406 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
40407 }
40408 arg2 = static_cast< int >(val2);
40409 {
40410 PyThreadState* __tstate = wxPyBeginAllowThreads();
40411 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
40412 wxPyEndAllowThreads(__tstate);
40413 if (PyErr_Occurred()) SWIG_fail;
40414 }
40415 {
40416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40417 }
40418 return resultobj;
40419 fail:
40420 return NULL;
40421 }
40422
40423
40424 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40425 PyObject *resultobj = 0;
40426 wxMenu *arg1 = (wxMenu *) 0 ;
40427 int arg2 ;
40428 bool arg3 ;
40429 void *argp1 = 0 ;
40430 int res1 = 0 ;
40431 int val2 ;
40432 int ecode2 = 0 ;
40433 bool val3 ;
40434 int ecode3 = 0 ;
40435 PyObject * obj0 = 0 ;
40436 PyObject * obj1 = 0 ;
40437 PyObject * obj2 = 0 ;
40438 char * kwnames[] = {
40439 (char *) "self",(char *) "id",(char *) "check", NULL
40440 };
40441
40442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40444 if (!SWIG_IsOK(res1)) {
40445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
40446 }
40447 arg1 = reinterpret_cast< wxMenu * >(argp1);
40448 ecode2 = SWIG_AsVal_int(obj1, &val2);
40449 if (!SWIG_IsOK(ecode2)) {
40450 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
40451 }
40452 arg2 = static_cast< int >(val2);
40453 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40454 if (!SWIG_IsOK(ecode3)) {
40455 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
40456 }
40457 arg3 = static_cast< bool >(val3);
40458 {
40459 PyThreadState* __tstate = wxPyBeginAllowThreads();
40460 (arg1)->Check(arg2,arg3);
40461 wxPyEndAllowThreads(__tstate);
40462 if (PyErr_Occurred()) SWIG_fail;
40463 }
40464 resultobj = SWIG_Py_Void();
40465 return resultobj;
40466 fail:
40467 return NULL;
40468 }
40469
40470
40471 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40472 PyObject *resultobj = 0;
40473 wxMenu *arg1 = (wxMenu *) 0 ;
40474 int arg2 ;
40475 bool result;
40476 void *argp1 = 0 ;
40477 int res1 = 0 ;
40478 int val2 ;
40479 int ecode2 = 0 ;
40480 PyObject * obj0 = 0 ;
40481 PyObject * obj1 = 0 ;
40482 char * kwnames[] = {
40483 (char *) "self",(char *) "id", NULL
40484 };
40485
40486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
40487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40488 if (!SWIG_IsOK(res1)) {
40489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
40490 }
40491 arg1 = reinterpret_cast< wxMenu * >(argp1);
40492 ecode2 = SWIG_AsVal_int(obj1, &val2);
40493 if (!SWIG_IsOK(ecode2)) {
40494 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
40495 }
40496 arg2 = static_cast< int >(val2);
40497 {
40498 PyThreadState* __tstate = wxPyBeginAllowThreads();
40499 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
40500 wxPyEndAllowThreads(__tstate);
40501 if (PyErr_Occurred()) SWIG_fail;
40502 }
40503 {
40504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40505 }
40506 return resultobj;
40507 fail:
40508 return NULL;
40509 }
40510
40511
40512 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40513 PyObject *resultobj = 0;
40514 wxMenu *arg1 = (wxMenu *) 0 ;
40515 int arg2 ;
40516 wxString *arg3 = 0 ;
40517 void *argp1 = 0 ;
40518 int res1 = 0 ;
40519 int val2 ;
40520 int ecode2 = 0 ;
40521 bool temp3 = false ;
40522 PyObject * obj0 = 0 ;
40523 PyObject * obj1 = 0 ;
40524 PyObject * obj2 = 0 ;
40525 char * kwnames[] = {
40526 (char *) "self",(char *) "id",(char *) "label", NULL
40527 };
40528
40529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40531 if (!SWIG_IsOK(res1)) {
40532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
40533 }
40534 arg1 = reinterpret_cast< wxMenu * >(argp1);
40535 ecode2 = SWIG_AsVal_int(obj1, &val2);
40536 if (!SWIG_IsOK(ecode2)) {
40537 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
40538 }
40539 arg2 = static_cast< int >(val2);
40540 {
40541 arg3 = wxString_in_helper(obj2);
40542 if (arg3 == NULL) SWIG_fail;
40543 temp3 = true;
40544 }
40545 {
40546 PyThreadState* __tstate = wxPyBeginAllowThreads();
40547 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
40548 wxPyEndAllowThreads(__tstate);
40549 if (PyErr_Occurred()) SWIG_fail;
40550 }
40551 resultobj = SWIG_Py_Void();
40552 {
40553 if (temp3)
40554 delete arg3;
40555 }
40556 return resultobj;
40557 fail:
40558 {
40559 if (temp3)
40560 delete arg3;
40561 }
40562 return NULL;
40563 }
40564
40565
40566 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40567 PyObject *resultobj = 0;
40568 wxMenu *arg1 = (wxMenu *) 0 ;
40569 int arg2 ;
40570 wxString result;
40571 void *argp1 = 0 ;
40572 int res1 = 0 ;
40573 int val2 ;
40574 int ecode2 = 0 ;
40575 PyObject * obj0 = 0 ;
40576 PyObject * obj1 = 0 ;
40577 char * kwnames[] = {
40578 (char *) "self",(char *) "id", NULL
40579 };
40580
40581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
40582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40583 if (!SWIG_IsOK(res1)) {
40584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
40585 }
40586 arg1 = reinterpret_cast< wxMenu * >(argp1);
40587 ecode2 = SWIG_AsVal_int(obj1, &val2);
40588 if (!SWIG_IsOK(ecode2)) {
40589 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
40590 }
40591 arg2 = static_cast< int >(val2);
40592 {
40593 PyThreadState* __tstate = wxPyBeginAllowThreads();
40594 result = ((wxMenu const *)arg1)->GetLabel(arg2);
40595 wxPyEndAllowThreads(__tstate);
40596 if (PyErr_Occurred()) SWIG_fail;
40597 }
40598 {
40599 #if wxUSE_UNICODE
40600 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40601 #else
40602 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40603 #endif
40604 }
40605 return resultobj;
40606 fail:
40607 return NULL;
40608 }
40609
40610
40611 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40612 PyObject *resultobj = 0;
40613 wxMenu *arg1 = (wxMenu *) 0 ;
40614 int arg2 ;
40615 wxString *arg3 = 0 ;
40616 void *argp1 = 0 ;
40617 int res1 = 0 ;
40618 int val2 ;
40619 int ecode2 = 0 ;
40620 bool temp3 = false ;
40621 PyObject * obj0 = 0 ;
40622 PyObject * obj1 = 0 ;
40623 PyObject * obj2 = 0 ;
40624 char * kwnames[] = {
40625 (char *) "self",(char *) "id",(char *) "helpString", NULL
40626 };
40627
40628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40630 if (!SWIG_IsOK(res1)) {
40631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
40632 }
40633 arg1 = reinterpret_cast< wxMenu * >(argp1);
40634 ecode2 = SWIG_AsVal_int(obj1, &val2);
40635 if (!SWIG_IsOK(ecode2)) {
40636 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
40637 }
40638 arg2 = static_cast< int >(val2);
40639 {
40640 arg3 = wxString_in_helper(obj2);
40641 if (arg3 == NULL) SWIG_fail;
40642 temp3 = true;
40643 }
40644 {
40645 PyThreadState* __tstate = wxPyBeginAllowThreads();
40646 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
40647 wxPyEndAllowThreads(__tstate);
40648 if (PyErr_Occurred()) SWIG_fail;
40649 }
40650 resultobj = SWIG_Py_Void();
40651 {
40652 if (temp3)
40653 delete arg3;
40654 }
40655 return resultobj;
40656 fail:
40657 {
40658 if (temp3)
40659 delete arg3;
40660 }
40661 return NULL;
40662 }
40663
40664
40665 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40666 PyObject *resultobj = 0;
40667 wxMenu *arg1 = (wxMenu *) 0 ;
40668 int arg2 ;
40669 wxString result;
40670 void *argp1 = 0 ;
40671 int res1 = 0 ;
40672 int val2 ;
40673 int ecode2 = 0 ;
40674 PyObject * obj0 = 0 ;
40675 PyObject * obj1 = 0 ;
40676 char * kwnames[] = {
40677 (char *) "self",(char *) "id", NULL
40678 };
40679
40680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
40681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40682 if (!SWIG_IsOK(res1)) {
40683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
40684 }
40685 arg1 = reinterpret_cast< wxMenu * >(argp1);
40686 ecode2 = SWIG_AsVal_int(obj1, &val2);
40687 if (!SWIG_IsOK(ecode2)) {
40688 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
40689 }
40690 arg2 = static_cast< int >(val2);
40691 {
40692 PyThreadState* __tstate = wxPyBeginAllowThreads();
40693 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
40694 wxPyEndAllowThreads(__tstate);
40695 if (PyErr_Occurred()) SWIG_fail;
40696 }
40697 {
40698 #if wxUSE_UNICODE
40699 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40700 #else
40701 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40702 #endif
40703 }
40704 return resultobj;
40705 fail:
40706 return NULL;
40707 }
40708
40709
40710 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40711 PyObject *resultobj = 0;
40712 wxMenu *arg1 = (wxMenu *) 0 ;
40713 wxString *arg2 = 0 ;
40714 void *argp1 = 0 ;
40715 int res1 = 0 ;
40716 bool temp2 = false ;
40717 PyObject * obj0 = 0 ;
40718 PyObject * obj1 = 0 ;
40719 char * kwnames[] = {
40720 (char *) "self",(char *) "title", NULL
40721 };
40722
40723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
40724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40725 if (!SWIG_IsOK(res1)) {
40726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
40727 }
40728 arg1 = reinterpret_cast< wxMenu * >(argp1);
40729 {
40730 arg2 = wxString_in_helper(obj1);
40731 if (arg2 == NULL) SWIG_fail;
40732 temp2 = true;
40733 }
40734 {
40735 PyThreadState* __tstate = wxPyBeginAllowThreads();
40736 (arg1)->SetTitle((wxString const &)*arg2);
40737 wxPyEndAllowThreads(__tstate);
40738 if (PyErr_Occurred()) SWIG_fail;
40739 }
40740 resultobj = SWIG_Py_Void();
40741 {
40742 if (temp2)
40743 delete arg2;
40744 }
40745 return resultobj;
40746 fail:
40747 {
40748 if (temp2)
40749 delete arg2;
40750 }
40751 return NULL;
40752 }
40753
40754
40755 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40756 PyObject *resultobj = 0;
40757 wxMenu *arg1 = (wxMenu *) 0 ;
40758 wxString result;
40759 void *argp1 = 0 ;
40760 int res1 = 0 ;
40761 PyObject *swig_obj[1] ;
40762
40763 if (!args) SWIG_fail;
40764 swig_obj[0] = args;
40765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40766 if (!SWIG_IsOK(res1)) {
40767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40768 }
40769 arg1 = reinterpret_cast< wxMenu * >(argp1);
40770 {
40771 PyThreadState* __tstate = wxPyBeginAllowThreads();
40772 result = ((wxMenu const *)arg1)->GetTitle();
40773 wxPyEndAllowThreads(__tstate);
40774 if (PyErr_Occurred()) SWIG_fail;
40775 }
40776 {
40777 #if wxUSE_UNICODE
40778 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40779 #else
40780 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40781 #endif
40782 }
40783 return resultobj;
40784 fail:
40785 return NULL;
40786 }
40787
40788
40789 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40790 PyObject *resultobj = 0;
40791 wxMenu *arg1 = (wxMenu *) 0 ;
40792 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
40793 void *argp1 = 0 ;
40794 int res1 = 0 ;
40795 void *argp2 = 0 ;
40796 int res2 = 0 ;
40797 PyObject * obj0 = 0 ;
40798 PyObject * obj1 = 0 ;
40799 char * kwnames[] = {
40800 (char *) "self",(char *) "handler", NULL
40801 };
40802
40803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
40804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40805 if (!SWIG_IsOK(res1)) {
40806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
40807 }
40808 arg1 = reinterpret_cast< wxMenu * >(argp1);
40809 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40810 if (!SWIG_IsOK(res2)) {
40811 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40812 }
40813 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40814 {
40815 PyThreadState* __tstate = wxPyBeginAllowThreads();
40816 (arg1)->SetEventHandler(arg2);
40817 wxPyEndAllowThreads(__tstate);
40818 if (PyErr_Occurred()) SWIG_fail;
40819 }
40820 resultobj = SWIG_Py_Void();
40821 return resultobj;
40822 fail:
40823 return NULL;
40824 }
40825
40826
40827 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40828 PyObject *resultobj = 0;
40829 wxMenu *arg1 = (wxMenu *) 0 ;
40830 wxEvtHandler *result = 0 ;
40831 void *argp1 = 0 ;
40832 int res1 = 0 ;
40833 PyObject *swig_obj[1] ;
40834
40835 if (!args) SWIG_fail;
40836 swig_obj[0] = args;
40837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40838 if (!SWIG_IsOK(res1)) {
40839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
40840 }
40841 arg1 = reinterpret_cast< wxMenu * >(argp1);
40842 {
40843 PyThreadState* __tstate = wxPyBeginAllowThreads();
40844 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
40845 wxPyEndAllowThreads(__tstate);
40846 if (PyErr_Occurred()) SWIG_fail;
40847 }
40848 {
40849 resultobj = wxPyMake_wxObject(result, 0);
40850 }
40851 return resultobj;
40852 fail:
40853 return NULL;
40854 }
40855
40856
40857 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40858 PyObject *resultobj = 0;
40859 wxMenu *arg1 = (wxMenu *) 0 ;
40860 wxWindow *arg2 = (wxWindow *) 0 ;
40861 void *argp1 = 0 ;
40862 int res1 = 0 ;
40863 void *argp2 = 0 ;
40864 int res2 = 0 ;
40865 PyObject * obj0 = 0 ;
40866 PyObject * obj1 = 0 ;
40867 char * kwnames[] = {
40868 (char *) "self",(char *) "win", NULL
40869 };
40870
40871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
40872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40873 if (!SWIG_IsOK(res1)) {
40874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
40875 }
40876 arg1 = reinterpret_cast< wxMenu * >(argp1);
40877 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
40878 if (!SWIG_IsOK(res2)) {
40879 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
40880 }
40881 arg2 = reinterpret_cast< wxWindow * >(argp2);
40882 {
40883 PyThreadState* __tstate = wxPyBeginAllowThreads();
40884 (arg1)->SetInvokingWindow(arg2);
40885 wxPyEndAllowThreads(__tstate);
40886 if (PyErr_Occurred()) SWIG_fail;
40887 }
40888 resultobj = SWIG_Py_Void();
40889 return resultobj;
40890 fail:
40891 return NULL;
40892 }
40893
40894
40895 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40896 PyObject *resultobj = 0;
40897 wxMenu *arg1 = (wxMenu *) 0 ;
40898 wxWindow *result = 0 ;
40899 void *argp1 = 0 ;
40900 int res1 = 0 ;
40901 PyObject *swig_obj[1] ;
40902
40903 if (!args) SWIG_fail;
40904 swig_obj[0] = args;
40905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40906 if (!SWIG_IsOK(res1)) {
40907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
40908 }
40909 arg1 = reinterpret_cast< wxMenu * >(argp1);
40910 {
40911 PyThreadState* __tstate = wxPyBeginAllowThreads();
40912 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
40913 wxPyEndAllowThreads(__tstate);
40914 if (PyErr_Occurred()) SWIG_fail;
40915 }
40916 {
40917 resultobj = wxPyMake_wxObject(result, 0);
40918 }
40919 return resultobj;
40920 fail:
40921 return NULL;
40922 }
40923
40924
40925 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40926 PyObject *resultobj = 0;
40927 wxMenu *arg1 = (wxMenu *) 0 ;
40928 long result;
40929 void *argp1 = 0 ;
40930 int res1 = 0 ;
40931 PyObject *swig_obj[1] ;
40932
40933 if (!args) SWIG_fail;
40934 swig_obj[0] = args;
40935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40936 if (!SWIG_IsOK(res1)) {
40937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40938 }
40939 arg1 = reinterpret_cast< wxMenu * >(argp1);
40940 {
40941 PyThreadState* __tstate = wxPyBeginAllowThreads();
40942 result = (long)((wxMenu const *)arg1)->GetStyle();
40943 wxPyEndAllowThreads(__tstate);
40944 if (PyErr_Occurred()) SWIG_fail;
40945 }
40946 resultobj = SWIG_From_long(static_cast< long >(result));
40947 return resultobj;
40948 fail:
40949 return NULL;
40950 }
40951
40952
40953 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40954 PyObject *resultobj = 0;
40955 wxMenu *arg1 = (wxMenu *) 0 ;
40956 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
40957 void *argp1 = 0 ;
40958 int res1 = 0 ;
40959 void *argp2 = 0 ;
40960 int res2 = 0 ;
40961 PyObject * obj0 = 0 ;
40962 PyObject * obj1 = 0 ;
40963 char * kwnames[] = {
40964 (char *) "self",(char *) "source", NULL
40965 };
40966
40967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
40968 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40969 if (!SWIG_IsOK(res1)) {
40970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
40971 }
40972 arg1 = reinterpret_cast< wxMenu * >(argp1);
40973 if (obj1) {
40974 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40975 if (!SWIG_IsOK(res2)) {
40976 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40977 }
40978 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40979 }
40980 {
40981 PyThreadState* __tstate = wxPyBeginAllowThreads();
40982 (arg1)->UpdateUI(arg2);
40983 wxPyEndAllowThreads(__tstate);
40984 if (PyErr_Occurred()) SWIG_fail;
40985 }
40986 resultobj = SWIG_Py_Void();
40987 return resultobj;
40988 fail:
40989 return NULL;
40990 }
40991
40992
40993 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40994 PyObject *resultobj = 0;
40995 wxMenu *arg1 = (wxMenu *) 0 ;
40996 wxMenuBar *result = 0 ;
40997 void *argp1 = 0 ;
40998 int res1 = 0 ;
40999 PyObject *swig_obj[1] ;
41000
41001 if (!args) SWIG_fail;
41002 swig_obj[0] = args;
41003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41004 if (!SWIG_IsOK(res1)) {
41005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
41006 }
41007 arg1 = reinterpret_cast< wxMenu * >(argp1);
41008 {
41009 PyThreadState* __tstate = wxPyBeginAllowThreads();
41010 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
41011 wxPyEndAllowThreads(__tstate);
41012 if (PyErr_Occurred()) SWIG_fail;
41013 }
41014 {
41015 resultobj = wxPyMake_wxObject(result, (bool)0);
41016 }
41017 return resultobj;
41018 fail:
41019 return NULL;
41020 }
41021
41022
41023 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41024 PyObject *resultobj = 0;
41025 wxMenu *arg1 = (wxMenu *) 0 ;
41026 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
41027 void *argp1 = 0 ;
41028 int res1 = 0 ;
41029 void *argp2 = 0 ;
41030 int res2 = 0 ;
41031 PyObject * obj0 = 0 ;
41032 PyObject * obj1 = 0 ;
41033 char * kwnames[] = {
41034 (char *) "self",(char *) "menubar", NULL
41035 };
41036
41037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
41038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41039 if (!SWIG_IsOK(res1)) {
41040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
41041 }
41042 arg1 = reinterpret_cast< wxMenu * >(argp1);
41043 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
41044 if (!SWIG_IsOK(res2)) {
41045 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
41046 }
41047 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
41048 {
41049 PyThreadState* __tstate = wxPyBeginAllowThreads();
41050 (arg1)->Attach(arg2);
41051 wxPyEndAllowThreads(__tstate);
41052 if (PyErr_Occurred()) SWIG_fail;
41053 }
41054 resultobj = SWIG_Py_Void();
41055 return resultobj;
41056 fail:
41057 return NULL;
41058 }
41059
41060
41061 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41062 PyObject *resultobj = 0;
41063 wxMenu *arg1 = (wxMenu *) 0 ;
41064 void *argp1 = 0 ;
41065 int res1 = 0 ;
41066 PyObject *swig_obj[1] ;
41067
41068 if (!args) SWIG_fail;
41069 swig_obj[0] = args;
41070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41071 if (!SWIG_IsOK(res1)) {
41072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
41073 }
41074 arg1 = reinterpret_cast< wxMenu * >(argp1);
41075 {
41076 PyThreadState* __tstate = wxPyBeginAllowThreads();
41077 (arg1)->Detach();
41078 wxPyEndAllowThreads(__tstate);
41079 if (PyErr_Occurred()) SWIG_fail;
41080 }
41081 resultobj = SWIG_Py_Void();
41082 return resultobj;
41083 fail:
41084 return NULL;
41085 }
41086
41087
41088 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41089 PyObject *resultobj = 0;
41090 wxMenu *arg1 = (wxMenu *) 0 ;
41091 bool result;
41092 void *argp1 = 0 ;
41093 int res1 = 0 ;
41094 PyObject *swig_obj[1] ;
41095
41096 if (!args) SWIG_fail;
41097 swig_obj[0] = args;
41098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41099 if (!SWIG_IsOK(res1)) {
41100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
41101 }
41102 arg1 = reinterpret_cast< wxMenu * >(argp1);
41103 {
41104 PyThreadState* __tstate = wxPyBeginAllowThreads();
41105 result = (bool)((wxMenu const *)arg1)->IsAttached();
41106 wxPyEndAllowThreads(__tstate);
41107 if (PyErr_Occurred()) SWIG_fail;
41108 }
41109 {
41110 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41111 }
41112 return resultobj;
41113 fail:
41114 return NULL;
41115 }
41116
41117
41118 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41119 PyObject *resultobj = 0;
41120 wxMenu *arg1 = (wxMenu *) 0 ;
41121 wxMenu *arg2 = (wxMenu *) 0 ;
41122 void *argp1 = 0 ;
41123 int res1 = 0 ;
41124 void *argp2 = 0 ;
41125 int res2 = 0 ;
41126 PyObject * obj0 = 0 ;
41127 PyObject * obj1 = 0 ;
41128 char * kwnames[] = {
41129 (char *) "self",(char *) "parent", NULL
41130 };
41131
41132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
41133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41134 if (!SWIG_IsOK(res1)) {
41135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
41136 }
41137 arg1 = reinterpret_cast< wxMenu * >(argp1);
41138 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41139 if (!SWIG_IsOK(res2)) {
41140 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
41141 }
41142 arg2 = reinterpret_cast< wxMenu * >(argp2);
41143 {
41144 PyThreadState* __tstate = wxPyBeginAllowThreads();
41145 (arg1)->SetParent(arg2);
41146 wxPyEndAllowThreads(__tstate);
41147 if (PyErr_Occurred()) SWIG_fail;
41148 }
41149 resultobj = SWIG_Py_Void();
41150 return resultobj;
41151 fail:
41152 return NULL;
41153 }
41154
41155
41156 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41157 PyObject *resultobj = 0;
41158 wxMenu *arg1 = (wxMenu *) 0 ;
41159 wxMenu *result = 0 ;
41160 void *argp1 = 0 ;
41161 int res1 = 0 ;
41162 PyObject *swig_obj[1] ;
41163
41164 if (!args) SWIG_fail;
41165 swig_obj[0] = args;
41166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41167 if (!SWIG_IsOK(res1)) {
41168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
41169 }
41170 arg1 = reinterpret_cast< wxMenu * >(argp1);
41171 {
41172 PyThreadState* __tstate = wxPyBeginAllowThreads();
41173 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
41174 wxPyEndAllowThreads(__tstate);
41175 if (PyErr_Occurred()) SWIG_fail;
41176 }
41177 {
41178 resultobj = wxPyMake_wxObject(result, 0);
41179 }
41180 return resultobj;
41181 fail:
41182 return NULL;
41183 }
41184
41185
41186 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41187 PyObject *obj;
41188 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41189 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
41190 return SWIG_Py_Void();
41191 }
41192
41193 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41194 return SWIG_Python_InitShadowInstance(args);
41195 }
41196
41197 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41198 PyObject *resultobj = 0;
41199 long arg1 = (long) 0 ;
41200 wxMenuBar *result = 0 ;
41201 long val1 ;
41202 int ecode1 = 0 ;
41203 PyObject * obj0 = 0 ;
41204 char * kwnames[] = {
41205 (char *) "style", NULL
41206 };
41207
41208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
41209 if (obj0) {
41210 ecode1 = SWIG_AsVal_long(obj0, &val1);
41211 if (!SWIG_IsOK(ecode1)) {
41212 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
41213 }
41214 arg1 = static_cast< long >(val1);
41215 }
41216 {
41217 if (!wxPyCheckForApp()) SWIG_fail;
41218 PyThreadState* __tstate = wxPyBeginAllowThreads();
41219 result = (wxMenuBar *)new wxMenuBar(arg1);
41220 wxPyEndAllowThreads(__tstate);
41221 if (PyErr_Occurred()) SWIG_fail;
41222 }
41223 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
41224 return resultobj;
41225 fail:
41226 return NULL;
41227 }
41228
41229
41230 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41231 PyObject *resultobj = 0;
41232 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41233 wxMenu *arg2 = (wxMenu *) 0 ;
41234 wxString *arg3 = 0 ;
41235 bool result;
41236 void *argp1 = 0 ;
41237 int res1 = 0 ;
41238 void *argp2 = 0 ;
41239 int res2 = 0 ;
41240 bool temp3 = false ;
41241 PyObject * obj0 = 0 ;
41242 PyObject * obj1 = 0 ;
41243 PyObject * obj2 = 0 ;
41244 char * kwnames[] = {
41245 (char *) "self",(char *) "menu",(char *) "title", NULL
41246 };
41247
41248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41250 if (!SWIG_IsOK(res1)) {
41251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41252 }
41253 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41254 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41255 if (!SWIG_IsOK(res2)) {
41256 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
41257 }
41258 arg2 = reinterpret_cast< wxMenu * >(argp2);
41259 {
41260 arg3 = wxString_in_helper(obj2);
41261 if (arg3 == NULL) SWIG_fail;
41262 temp3 = true;
41263 }
41264 {
41265 PyThreadState* __tstate = wxPyBeginAllowThreads();
41266 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
41267 wxPyEndAllowThreads(__tstate);
41268 if (PyErr_Occurred()) SWIG_fail;
41269 }
41270 {
41271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41272 }
41273 {
41274 if (temp3)
41275 delete arg3;
41276 }
41277 return resultobj;
41278 fail:
41279 {
41280 if (temp3)
41281 delete arg3;
41282 }
41283 return NULL;
41284 }
41285
41286
41287 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41288 PyObject *resultobj = 0;
41289 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41290 size_t arg2 ;
41291 wxMenu *arg3 = (wxMenu *) 0 ;
41292 wxString *arg4 = 0 ;
41293 bool result;
41294 void *argp1 = 0 ;
41295 int res1 = 0 ;
41296 size_t val2 ;
41297 int ecode2 = 0 ;
41298 void *argp3 = 0 ;
41299 int res3 = 0 ;
41300 bool temp4 = false ;
41301 PyObject * obj0 = 0 ;
41302 PyObject * obj1 = 0 ;
41303 PyObject * obj2 = 0 ;
41304 PyObject * obj3 = 0 ;
41305 char * kwnames[] = {
41306 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41307 };
41308
41309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41311 if (!SWIG_IsOK(res1)) {
41312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41313 }
41314 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41315 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41316 if (!SWIG_IsOK(ecode2)) {
41317 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
41318 }
41319 arg2 = static_cast< size_t >(val2);
41320 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41321 if (!SWIG_IsOK(res3)) {
41322 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
41323 }
41324 arg3 = reinterpret_cast< wxMenu * >(argp3);
41325 {
41326 arg4 = wxString_in_helper(obj3);
41327 if (arg4 == NULL) SWIG_fail;
41328 temp4 = true;
41329 }
41330 {
41331 PyThreadState* __tstate = wxPyBeginAllowThreads();
41332 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
41333 wxPyEndAllowThreads(__tstate);
41334 if (PyErr_Occurred()) SWIG_fail;
41335 }
41336 {
41337 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41338 }
41339 {
41340 if (temp4)
41341 delete arg4;
41342 }
41343 return resultobj;
41344 fail:
41345 {
41346 if (temp4)
41347 delete arg4;
41348 }
41349 return NULL;
41350 }
41351
41352
41353 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41354 PyObject *resultobj = 0;
41355 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41356 size_t result;
41357 void *argp1 = 0 ;
41358 int res1 = 0 ;
41359 PyObject *swig_obj[1] ;
41360
41361 if (!args) SWIG_fail;
41362 swig_obj[0] = args;
41363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41364 if (!SWIG_IsOK(res1)) {
41365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41366 }
41367 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41368 {
41369 PyThreadState* __tstate = wxPyBeginAllowThreads();
41370 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
41371 wxPyEndAllowThreads(__tstate);
41372 if (PyErr_Occurred()) SWIG_fail;
41373 }
41374 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
41375 return resultobj;
41376 fail:
41377 return NULL;
41378 }
41379
41380
41381 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41382 PyObject *resultobj = 0;
41383 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41384 size_t arg2 ;
41385 wxMenu *result = 0 ;
41386 void *argp1 = 0 ;
41387 int res1 = 0 ;
41388 size_t val2 ;
41389 int ecode2 = 0 ;
41390 PyObject * obj0 = 0 ;
41391 PyObject * obj1 = 0 ;
41392 char * kwnames[] = {
41393 (char *) "self",(char *) "pos", NULL
41394 };
41395
41396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41398 if (!SWIG_IsOK(res1)) {
41399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41400 }
41401 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41402 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41403 if (!SWIG_IsOK(ecode2)) {
41404 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
41405 }
41406 arg2 = static_cast< size_t >(val2);
41407 {
41408 PyThreadState* __tstate = wxPyBeginAllowThreads();
41409 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
41410 wxPyEndAllowThreads(__tstate);
41411 if (PyErr_Occurred()) SWIG_fail;
41412 }
41413 {
41414 resultobj = wxPyMake_wxObject(result, 0);
41415 }
41416 return resultobj;
41417 fail:
41418 return NULL;
41419 }
41420
41421
41422 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41423 PyObject *resultobj = 0;
41424 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41425 size_t arg2 ;
41426 wxMenu *arg3 = (wxMenu *) 0 ;
41427 wxString *arg4 = 0 ;
41428 wxMenu *result = 0 ;
41429 void *argp1 = 0 ;
41430 int res1 = 0 ;
41431 size_t val2 ;
41432 int ecode2 = 0 ;
41433 void *argp3 = 0 ;
41434 int res3 = 0 ;
41435 bool temp4 = false ;
41436 PyObject * obj0 = 0 ;
41437 PyObject * obj1 = 0 ;
41438 PyObject * obj2 = 0 ;
41439 PyObject * obj3 = 0 ;
41440 char * kwnames[] = {
41441 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41442 };
41443
41444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41446 if (!SWIG_IsOK(res1)) {
41447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41448 }
41449 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41450 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41451 if (!SWIG_IsOK(ecode2)) {
41452 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
41453 }
41454 arg2 = static_cast< size_t >(val2);
41455 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41456 if (!SWIG_IsOK(res3)) {
41457 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
41458 }
41459 arg3 = reinterpret_cast< wxMenu * >(argp3);
41460 {
41461 arg4 = wxString_in_helper(obj3);
41462 if (arg4 == NULL) SWIG_fail;
41463 temp4 = true;
41464 }
41465 {
41466 PyThreadState* __tstate = wxPyBeginAllowThreads();
41467 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
41468 wxPyEndAllowThreads(__tstate);
41469 if (PyErr_Occurred()) SWIG_fail;
41470 }
41471 {
41472 resultobj = wxPyMake_wxObject(result, 0);
41473 }
41474 {
41475 if (temp4)
41476 delete arg4;
41477 }
41478 return resultobj;
41479 fail:
41480 {
41481 if (temp4)
41482 delete arg4;
41483 }
41484 return NULL;
41485 }
41486
41487
41488 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41489 PyObject *resultobj = 0;
41490 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41491 size_t arg2 ;
41492 wxMenu *result = 0 ;
41493 void *argp1 = 0 ;
41494 int res1 = 0 ;
41495 size_t val2 ;
41496 int ecode2 = 0 ;
41497 PyObject * obj0 = 0 ;
41498 PyObject * obj1 = 0 ;
41499 char * kwnames[] = {
41500 (char *) "self",(char *) "pos", NULL
41501 };
41502
41503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
41504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41505 if (!SWIG_IsOK(res1)) {
41506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41507 }
41508 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41509 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41510 if (!SWIG_IsOK(ecode2)) {
41511 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
41512 }
41513 arg2 = static_cast< size_t >(val2);
41514 {
41515 PyThreadState* __tstate = wxPyBeginAllowThreads();
41516 result = (wxMenu *)(arg1)->Remove(arg2);
41517 wxPyEndAllowThreads(__tstate);
41518 if (PyErr_Occurred()) SWIG_fail;
41519 }
41520 {
41521 resultobj = wxPyMake_wxObject(result, 0);
41522 }
41523 return resultobj;
41524 fail:
41525 return NULL;
41526 }
41527
41528
41529 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41530 PyObject *resultobj = 0;
41531 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41532 size_t arg2 ;
41533 bool arg3 ;
41534 void *argp1 = 0 ;
41535 int res1 = 0 ;
41536 size_t val2 ;
41537 int ecode2 = 0 ;
41538 bool val3 ;
41539 int ecode3 = 0 ;
41540 PyObject * obj0 = 0 ;
41541 PyObject * obj1 = 0 ;
41542 PyObject * obj2 = 0 ;
41543 char * kwnames[] = {
41544 (char *) "self",(char *) "pos",(char *) "enable", NULL
41545 };
41546
41547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41549 if (!SWIG_IsOK(res1)) {
41550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41551 }
41552 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41553 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41554 if (!SWIG_IsOK(ecode2)) {
41555 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
41556 }
41557 arg2 = static_cast< size_t >(val2);
41558 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41559 if (!SWIG_IsOK(ecode3)) {
41560 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
41561 }
41562 arg3 = static_cast< bool >(val3);
41563 {
41564 PyThreadState* __tstate = wxPyBeginAllowThreads();
41565 (arg1)->EnableTop(arg2,arg3);
41566 wxPyEndAllowThreads(__tstate);
41567 if (PyErr_Occurred()) SWIG_fail;
41568 }
41569 resultobj = SWIG_Py_Void();
41570 return resultobj;
41571 fail:
41572 return NULL;
41573 }
41574
41575
41576 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41577 PyObject *resultobj = 0;
41578 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41579 size_t arg2 ;
41580 bool result;
41581 void *argp1 = 0 ;
41582 int res1 = 0 ;
41583 size_t val2 ;
41584 int ecode2 = 0 ;
41585 PyObject * obj0 = 0 ;
41586 PyObject * obj1 = 0 ;
41587 char * kwnames[] = {
41588 (char *) "self",(char *) "pos", NULL
41589 };
41590
41591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
41592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41593 if (!SWIG_IsOK(res1)) {
41594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41595 }
41596 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41597 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41598 if (!SWIG_IsOK(ecode2)) {
41599 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
41600 }
41601 arg2 = static_cast< size_t >(val2);
41602 {
41603 PyThreadState* __tstate = wxPyBeginAllowThreads();
41604 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
41605 wxPyEndAllowThreads(__tstate);
41606 if (PyErr_Occurred()) SWIG_fail;
41607 }
41608 {
41609 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41610 }
41611 return resultobj;
41612 fail:
41613 return NULL;
41614 }
41615
41616
41617 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41618 PyObject *resultobj = 0;
41619 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41620 size_t arg2 ;
41621 wxString *arg3 = 0 ;
41622 void *argp1 = 0 ;
41623 int res1 = 0 ;
41624 size_t val2 ;
41625 int ecode2 = 0 ;
41626 bool temp3 = false ;
41627 PyObject * obj0 = 0 ;
41628 PyObject * obj1 = 0 ;
41629 PyObject * obj2 = 0 ;
41630 char * kwnames[] = {
41631 (char *) "self",(char *) "pos",(char *) "label", NULL
41632 };
41633
41634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41636 if (!SWIG_IsOK(res1)) {
41637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41638 }
41639 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41640 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41641 if (!SWIG_IsOK(ecode2)) {
41642 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41643 }
41644 arg2 = static_cast< size_t >(val2);
41645 {
41646 arg3 = wxString_in_helper(obj2);
41647 if (arg3 == NULL) SWIG_fail;
41648 temp3 = true;
41649 }
41650 {
41651 PyThreadState* __tstate = wxPyBeginAllowThreads();
41652 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
41653 wxPyEndAllowThreads(__tstate);
41654 if (PyErr_Occurred()) SWIG_fail;
41655 }
41656 resultobj = SWIG_Py_Void();
41657 {
41658 if (temp3)
41659 delete arg3;
41660 }
41661 return resultobj;
41662 fail:
41663 {
41664 if (temp3)
41665 delete arg3;
41666 }
41667 return NULL;
41668 }
41669
41670
41671 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41672 PyObject *resultobj = 0;
41673 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41674 size_t arg2 ;
41675 wxString result;
41676 void *argp1 = 0 ;
41677 int res1 = 0 ;
41678 size_t val2 ;
41679 int ecode2 = 0 ;
41680 PyObject * obj0 = 0 ;
41681 PyObject * obj1 = 0 ;
41682 char * kwnames[] = {
41683 (char *) "self",(char *) "pos", NULL
41684 };
41685
41686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
41687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41688 if (!SWIG_IsOK(res1)) {
41689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41690 }
41691 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41692 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41693 if (!SWIG_IsOK(ecode2)) {
41694 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41695 }
41696 arg2 = static_cast< size_t >(val2);
41697 {
41698 PyThreadState* __tstate = wxPyBeginAllowThreads();
41699 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
41700 wxPyEndAllowThreads(__tstate);
41701 if (PyErr_Occurred()) SWIG_fail;
41702 }
41703 {
41704 #if wxUSE_UNICODE
41705 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41706 #else
41707 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41708 #endif
41709 }
41710 return resultobj;
41711 fail:
41712 return NULL;
41713 }
41714
41715
41716 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41717 PyObject *resultobj = 0;
41718 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41719 wxString *arg2 = 0 ;
41720 wxString *arg3 = 0 ;
41721 int result;
41722 void *argp1 = 0 ;
41723 int res1 = 0 ;
41724 bool temp2 = false ;
41725 bool temp3 = false ;
41726 PyObject * obj0 = 0 ;
41727 PyObject * obj1 = 0 ;
41728 PyObject * obj2 = 0 ;
41729 char * kwnames[] = {
41730 (char *) "self",(char *) "menu",(char *) "item", NULL
41731 };
41732
41733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41735 if (!SWIG_IsOK(res1)) {
41736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41737 }
41738 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41739 {
41740 arg2 = wxString_in_helper(obj1);
41741 if (arg2 == NULL) SWIG_fail;
41742 temp2 = true;
41743 }
41744 {
41745 arg3 = wxString_in_helper(obj2);
41746 if (arg3 == NULL) SWIG_fail;
41747 temp3 = true;
41748 }
41749 {
41750 PyThreadState* __tstate = wxPyBeginAllowThreads();
41751 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
41752 wxPyEndAllowThreads(__tstate);
41753 if (PyErr_Occurred()) SWIG_fail;
41754 }
41755 resultobj = SWIG_From_int(static_cast< int >(result));
41756 {
41757 if (temp2)
41758 delete arg2;
41759 }
41760 {
41761 if (temp3)
41762 delete arg3;
41763 }
41764 return resultobj;
41765 fail:
41766 {
41767 if (temp2)
41768 delete arg2;
41769 }
41770 {
41771 if (temp3)
41772 delete arg3;
41773 }
41774 return NULL;
41775 }
41776
41777
41778 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41779 PyObject *resultobj = 0;
41780 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41781 int arg2 ;
41782 wxMenuItem *result = 0 ;
41783 void *argp1 = 0 ;
41784 int res1 = 0 ;
41785 int val2 ;
41786 int ecode2 = 0 ;
41787 PyObject * obj0 = 0 ;
41788 PyObject * obj1 = 0 ;
41789 char * kwnames[] = {
41790 (char *) "self",(char *) "id", NULL
41791 };
41792
41793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41795 if (!SWIG_IsOK(res1)) {
41796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41797 }
41798 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41799 ecode2 = SWIG_AsVal_int(obj1, &val2);
41800 if (!SWIG_IsOK(ecode2)) {
41801 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
41802 }
41803 arg2 = static_cast< int >(val2);
41804 {
41805 PyThreadState* __tstate = wxPyBeginAllowThreads();
41806 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
41807 wxPyEndAllowThreads(__tstate);
41808 if (PyErr_Occurred()) SWIG_fail;
41809 }
41810 {
41811 resultobj = wxPyMake_wxObject(result, (bool)0);
41812 }
41813 return resultobj;
41814 fail:
41815 return NULL;
41816 }
41817
41818
41819 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41820 PyObject *resultobj = 0;
41821 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41822 wxString *arg2 = 0 ;
41823 int result;
41824 void *argp1 = 0 ;
41825 int res1 = 0 ;
41826 bool temp2 = false ;
41827 PyObject * obj0 = 0 ;
41828 PyObject * obj1 = 0 ;
41829 char * kwnames[] = {
41830 (char *) "self",(char *) "title", NULL
41831 };
41832
41833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41835 if (!SWIG_IsOK(res1)) {
41836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41837 }
41838 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41839 {
41840 arg2 = wxString_in_helper(obj1);
41841 if (arg2 == NULL) SWIG_fail;
41842 temp2 = true;
41843 }
41844 {
41845 PyThreadState* __tstate = wxPyBeginAllowThreads();
41846 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
41847 wxPyEndAllowThreads(__tstate);
41848 if (PyErr_Occurred()) SWIG_fail;
41849 }
41850 resultobj = SWIG_From_int(static_cast< int >(result));
41851 {
41852 if (temp2)
41853 delete arg2;
41854 }
41855 return resultobj;
41856 fail:
41857 {
41858 if (temp2)
41859 delete arg2;
41860 }
41861 return NULL;
41862 }
41863
41864
41865 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41866 PyObject *resultobj = 0;
41867 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41868 int arg2 ;
41869 bool arg3 ;
41870 void *argp1 = 0 ;
41871 int res1 = 0 ;
41872 int val2 ;
41873 int ecode2 = 0 ;
41874 bool val3 ;
41875 int ecode3 = 0 ;
41876 PyObject * obj0 = 0 ;
41877 PyObject * obj1 = 0 ;
41878 PyObject * obj2 = 0 ;
41879 char * kwnames[] = {
41880 (char *) "self",(char *) "id",(char *) "enable", NULL
41881 };
41882
41883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41885 if (!SWIG_IsOK(res1)) {
41886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41887 }
41888 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41889 ecode2 = SWIG_AsVal_int(obj1, &val2);
41890 if (!SWIG_IsOK(ecode2)) {
41891 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
41892 }
41893 arg2 = static_cast< int >(val2);
41894 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41895 if (!SWIG_IsOK(ecode3)) {
41896 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
41897 }
41898 arg3 = static_cast< bool >(val3);
41899 {
41900 PyThreadState* __tstate = wxPyBeginAllowThreads();
41901 (arg1)->Enable(arg2,arg3);
41902 wxPyEndAllowThreads(__tstate);
41903 if (PyErr_Occurred()) SWIG_fail;
41904 }
41905 resultobj = SWIG_Py_Void();
41906 return resultobj;
41907 fail:
41908 return NULL;
41909 }
41910
41911
41912 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41913 PyObject *resultobj = 0;
41914 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41915 int arg2 ;
41916 bool arg3 ;
41917 void *argp1 = 0 ;
41918 int res1 = 0 ;
41919 int val2 ;
41920 int ecode2 = 0 ;
41921 bool val3 ;
41922 int ecode3 = 0 ;
41923 PyObject * obj0 = 0 ;
41924 PyObject * obj1 = 0 ;
41925 PyObject * obj2 = 0 ;
41926 char * kwnames[] = {
41927 (char *) "self",(char *) "id",(char *) "check", NULL
41928 };
41929
41930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41932 if (!SWIG_IsOK(res1)) {
41933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41934 }
41935 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41936 ecode2 = SWIG_AsVal_int(obj1, &val2);
41937 if (!SWIG_IsOK(ecode2)) {
41938 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
41939 }
41940 arg2 = static_cast< int >(val2);
41941 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41942 if (!SWIG_IsOK(ecode3)) {
41943 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
41944 }
41945 arg3 = static_cast< bool >(val3);
41946 {
41947 PyThreadState* __tstate = wxPyBeginAllowThreads();
41948 (arg1)->Check(arg2,arg3);
41949 wxPyEndAllowThreads(__tstate);
41950 if (PyErr_Occurred()) SWIG_fail;
41951 }
41952 resultobj = SWIG_Py_Void();
41953 return resultobj;
41954 fail:
41955 return NULL;
41956 }
41957
41958
41959 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41960 PyObject *resultobj = 0;
41961 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41962 int arg2 ;
41963 bool result;
41964 void *argp1 = 0 ;
41965 int res1 = 0 ;
41966 int val2 ;
41967 int ecode2 = 0 ;
41968 PyObject * obj0 = 0 ;
41969 PyObject * obj1 = 0 ;
41970 char * kwnames[] = {
41971 (char *) "self",(char *) "id", NULL
41972 };
41973
41974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41976 if (!SWIG_IsOK(res1)) {
41977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41978 }
41979 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41980 ecode2 = SWIG_AsVal_int(obj1, &val2);
41981 if (!SWIG_IsOK(ecode2)) {
41982 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
41983 }
41984 arg2 = static_cast< int >(val2);
41985 {
41986 PyThreadState* __tstate = wxPyBeginAllowThreads();
41987 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
41988 wxPyEndAllowThreads(__tstate);
41989 if (PyErr_Occurred()) SWIG_fail;
41990 }
41991 {
41992 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41993 }
41994 return resultobj;
41995 fail:
41996 return NULL;
41997 }
41998
41999
42000 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42001 PyObject *resultobj = 0;
42002 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42003 int arg2 ;
42004 bool result;
42005 void *argp1 = 0 ;
42006 int res1 = 0 ;
42007 int val2 ;
42008 int ecode2 = 0 ;
42009 PyObject * obj0 = 0 ;
42010 PyObject * obj1 = 0 ;
42011 char * kwnames[] = {
42012 (char *) "self",(char *) "id", NULL
42013 };
42014
42015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
42016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42017 if (!SWIG_IsOK(res1)) {
42018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42019 }
42020 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42021 ecode2 = SWIG_AsVal_int(obj1, &val2);
42022 if (!SWIG_IsOK(ecode2)) {
42023 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
42024 }
42025 arg2 = static_cast< int >(val2);
42026 {
42027 PyThreadState* __tstate = wxPyBeginAllowThreads();
42028 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
42029 wxPyEndAllowThreads(__tstate);
42030 if (PyErr_Occurred()) SWIG_fail;
42031 }
42032 {
42033 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42034 }
42035 return resultobj;
42036 fail:
42037 return NULL;
42038 }
42039
42040
42041 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42042 PyObject *resultobj = 0;
42043 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42044 int arg2 ;
42045 wxString *arg3 = 0 ;
42046 void *argp1 = 0 ;
42047 int res1 = 0 ;
42048 int val2 ;
42049 int ecode2 = 0 ;
42050 bool temp3 = false ;
42051 PyObject * obj0 = 0 ;
42052 PyObject * obj1 = 0 ;
42053 PyObject * obj2 = 0 ;
42054 char * kwnames[] = {
42055 (char *) "self",(char *) "id",(char *) "label", NULL
42056 };
42057
42058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42060 if (!SWIG_IsOK(res1)) {
42061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42062 }
42063 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42064 ecode2 = SWIG_AsVal_int(obj1, &val2);
42065 if (!SWIG_IsOK(ecode2)) {
42066 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
42067 }
42068 arg2 = static_cast< int >(val2);
42069 {
42070 arg3 = wxString_in_helper(obj2);
42071 if (arg3 == NULL) SWIG_fail;
42072 temp3 = true;
42073 }
42074 {
42075 PyThreadState* __tstate = wxPyBeginAllowThreads();
42076 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
42077 wxPyEndAllowThreads(__tstate);
42078 if (PyErr_Occurred()) SWIG_fail;
42079 }
42080 resultobj = SWIG_Py_Void();
42081 {
42082 if (temp3)
42083 delete arg3;
42084 }
42085 return resultobj;
42086 fail:
42087 {
42088 if (temp3)
42089 delete arg3;
42090 }
42091 return NULL;
42092 }
42093
42094
42095 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42096 PyObject *resultobj = 0;
42097 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42098 int arg2 ;
42099 wxString result;
42100 void *argp1 = 0 ;
42101 int res1 = 0 ;
42102 int val2 ;
42103 int ecode2 = 0 ;
42104 PyObject * obj0 = 0 ;
42105 PyObject * obj1 = 0 ;
42106 char * kwnames[] = {
42107 (char *) "self",(char *) "id", NULL
42108 };
42109
42110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
42111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42112 if (!SWIG_IsOK(res1)) {
42113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42114 }
42115 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42116 ecode2 = SWIG_AsVal_int(obj1, &val2);
42117 if (!SWIG_IsOK(ecode2)) {
42118 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
42119 }
42120 arg2 = static_cast< int >(val2);
42121 {
42122 PyThreadState* __tstate = wxPyBeginAllowThreads();
42123 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
42124 wxPyEndAllowThreads(__tstate);
42125 if (PyErr_Occurred()) SWIG_fail;
42126 }
42127 {
42128 #if wxUSE_UNICODE
42129 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42130 #else
42131 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42132 #endif
42133 }
42134 return resultobj;
42135 fail:
42136 return NULL;
42137 }
42138
42139
42140 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42141 PyObject *resultobj = 0;
42142 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42143 int arg2 ;
42144 wxString *arg3 = 0 ;
42145 void *argp1 = 0 ;
42146 int res1 = 0 ;
42147 int val2 ;
42148 int ecode2 = 0 ;
42149 bool temp3 = false ;
42150 PyObject * obj0 = 0 ;
42151 PyObject * obj1 = 0 ;
42152 PyObject * obj2 = 0 ;
42153 char * kwnames[] = {
42154 (char *) "self",(char *) "id",(char *) "helpString", NULL
42155 };
42156
42157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42159 if (!SWIG_IsOK(res1)) {
42160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42161 }
42162 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42163 ecode2 = SWIG_AsVal_int(obj1, &val2);
42164 if (!SWIG_IsOK(ecode2)) {
42165 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
42166 }
42167 arg2 = static_cast< int >(val2);
42168 {
42169 arg3 = wxString_in_helper(obj2);
42170 if (arg3 == NULL) SWIG_fail;
42171 temp3 = true;
42172 }
42173 {
42174 PyThreadState* __tstate = wxPyBeginAllowThreads();
42175 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
42176 wxPyEndAllowThreads(__tstate);
42177 if (PyErr_Occurred()) SWIG_fail;
42178 }
42179 resultobj = SWIG_Py_Void();
42180 {
42181 if (temp3)
42182 delete arg3;
42183 }
42184 return resultobj;
42185 fail:
42186 {
42187 if (temp3)
42188 delete arg3;
42189 }
42190 return NULL;
42191 }
42192
42193
42194 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42195 PyObject *resultobj = 0;
42196 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42197 int arg2 ;
42198 wxString result;
42199 void *argp1 = 0 ;
42200 int res1 = 0 ;
42201 int val2 ;
42202 int ecode2 = 0 ;
42203 PyObject * obj0 = 0 ;
42204 PyObject * obj1 = 0 ;
42205 char * kwnames[] = {
42206 (char *) "self",(char *) "id", NULL
42207 };
42208
42209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
42210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42211 if (!SWIG_IsOK(res1)) {
42212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42213 }
42214 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42215 ecode2 = SWIG_AsVal_int(obj1, &val2);
42216 if (!SWIG_IsOK(ecode2)) {
42217 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
42218 }
42219 arg2 = static_cast< int >(val2);
42220 {
42221 PyThreadState* __tstate = wxPyBeginAllowThreads();
42222 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
42223 wxPyEndAllowThreads(__tstate);
42224 if (PyErr_Occurred()) SWIG_fail;
42225 }
42226 {
42227 #if wxUSE_UNICODE
42228 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42229 #else
42230 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42231 #endif
42232 }
42233 return resultobj;
42234 fail:
42235 return NULL;
42236 }
42237
42238
42239 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42240 PyObject *resultobj = 0;
42241 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42242 wxFrame *result = 0 ;
42243 void *argp1 = 0 ;
42244 int res1 = 0 ;
42245 PyObject *swig_obj[1] ;
42246
42247 if (!args) SWIG_fail;
42248 swig_obj[0] = args;
42249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42250 if (!SWIG_IsOK(res1)) {
42251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42252 }
42253 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42254 {
42255 PyThreadState* __tstate = wxPyBeginAllowThreads();
42256 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
42257 wxPyEndAllowThreads(__tstate);
42258 if (PyErr_Occurred()) SWIG_fail;
42259 }
42260 {
42261 resultobj = wxPyMake_wxObject(result, (bool)0);
42262 }
42263 return resultobj;
42264 fail:
42265 return NULL;
42266 }
42267
42268
42269 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42270 PyObject *resultobj = 0;
42271 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42272 bool result;
42273 void *argp1 = 0 ;
42274 int res1 = 0 ;
42275 PyObject *swig_obj[1] ;
42276
42277 if (!args) SWIG_fail;
42278 swig_obj[0] = args;
42279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42280 if (!SWIG_IsOK(res1)) {
42281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42282 }
42283 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42284 {
42285 PyThreadState* __tstate = wxPyBeginAllowThreads();
42286 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
42287 wxPyEndAllowThreads(__tstate);
42288 if (PyErr_Occurred()) SWIG_fail;
42289 }
42290 {
42291 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42292 }
42293 return resultobj;
42294 fail:
42295 return NULL;
42296 }
42297
42298
42299 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42300 PyObject *resultobj = 0;
42301 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42302 wxFrame *arg2 = (wxFrame *) 0 ;
42303 void *argp1 = 0 ;
42304 int res1 = 0 ;
42305 void *argp2 = 0 ;
42306 int res2 = 0 ;
42307 PyObject * obj0 = 0 ;
42308 PyObject * obj1 = 0 ;
42309 char * kwnames[] = {
42310 (char *) "self",(char *) "frame", NULL
42311 };
42312
42313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
42314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42315 if (!SWIG_IsOK(res1)) {
42316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42317 }
42318 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42319 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
42320 if (!SWIG_IsOK(res2)) {
42321 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
42322 }
42323 arg2 = reinterpret_cast< wxFrame * >(argp2);
42324 {
42325 PyThreadState* __tstate = wxPyBeginAllowThreads();
42326 (arg1)->Attach(arg2);
42327 wxPyEndAllowThreads(__tstate);
42328 if (PyErr_Occurred()) SWIG_fail;
42329 }
42330 resultobj = SWIG_Py_Void();
42331 return resultobj;
42332 fail:
42333 return NULL;
42334 }
42335
42336
42337 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42338 PyObject *resultobj = 0;
42339 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42340 void *argp1 = 0 ;
42341 int res1 = 0 ;
42342 PyObject *swig_obj[1] ;
42343
42344 if (!args) SWIG_fail;
42345 swig_obj[0] = args;
42346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42347 if (!SWIG_IsOK(res1)) {
42348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42349 }
42350 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42351 {
42352 PyThreadState* __tstate = wxPyBeginAllowThreads();
42353 (arg1)->Detach();
42354 wxPyEndAllowThreads(__tstate);
42355 if (PyErr_Occurred()) SWIG_fail;
42356 }
42357 resultobj = SWIG_Py_Void();
42358 return resultobj;
42359 fail:
42360 return NULL;
42361 }
42362
42363
42364 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42365 PyObject *resultobj = 0;
42366 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42367 void *argp1 = 0 ;
42368 int res1 = 0 ;
42369 PyObject *swig_obj[1] ;
42370
42371 if (!args) SWIG_fail;
42372 swig_obj[0] = args;
42373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42374 if (!SWIG_IsOK(res1)) {
42375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42376 }
42377 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42378 {
42379 PyThreadState* __tstate = wxPyBeginAllowThreads();
42380 (arg1)->UpdateMenus();
42381 wxPyEndAllowThreads(__tstate);
42382 if (PyErr_Occurred()) SWIG_fail;
42383 }
42384 resultobj = SWIG_Py_Void();
42385 return resultobj;
42386 fail:
42387 return NULL;
42388 }
42389
42390
42391 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42392 PyObject *resultobj = 0;
42393 bool arg1 ;
42394 bool val1 ;
42395 int ecode1 = 0 ;
42396 PyObject * obj0 = 0 ;
42397 char * kwnames[] = {
42398 (char *) "enable", NULL
42399 };
42400
42401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
42402 ecode1 = SWIG_AsVal_bool(obj0, &val1);
42403 if (!SWIG_IsOK(ecode1)) {
42404 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
42405 }
42406 arg1 = static_cast< bool >(val1);
42407 {
42408 PyThreadState* __tstate = wxPyBeginAllowThreads();
42409 wxMenuBar::SetAutoWindowMenu(arg1);
42410 wxPyEndAllowThreads(__tstate);
42411 if (PyErr_Occurred()) SWIG_fail;
42412 }
42413 resultobj = SWIG_Py_Void();
42414 return resultobj;
42415 fail:
42416 return NULL;
42417 }
42418
42419
42420 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42421 PyObject *resultobj = 0;
42422 bool result;
42423
42424 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
42425 {
42426 PyThreadState* __tstate = wxPyBeginAllowThreads();
42427 result = (bool)wxMenuBar::GetAutoWindowMenu();
42428 wxPyEndAllowThreads(__tstate);
42429 if (PyErr_Occurred()) SWIG_fail;
42430 }
42431 {
42432 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42433 }
42434 return resultobj;
42435 fail:
42436 return NULL;
42437 }
42438
42439
42440 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42441 PyObject *obj;
42442 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42443 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
42444 return SWIG_Py_Void();
42445 }
42446
42447 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42448 return SWIG_Python_InitShadowInstance(args);
42449 }
42450
42451 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42452 PyObject *resultobj = 0;
42453 wxMenu *arg1 = (wxMenu *) NULL ;
42454 int arg2 = (int) wxID_ANY ;
42455 wxString const &arg3_defvalue = wxPyEmptyString ;
42456 wxString *arg3 = (wxString *) &arg3_defvalue ;
42457 wxString const &arg4_defvalue = wxPyEmptyString ;
42458 wxString *arg4 = (wxString *) &arg4_defvalue ;
42459 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42460 wxMenu *arg6 = (wxMenu *) NULL ;
42461 wxMenuItem *result = 0 ;
42462 void *argp1 = 0 ;
42463 int res1 = 0 ;
42464 int val2 ;
42465 int ecode2 = 0 ;
42466 bool temp3 = false ;
42467 bool temp4 = false ;
42468 int val5 ;
42469 int ecode5 = 0 ;
42470 void *argp6 = 0 ;
42471 int res6 = 0 ;
42472 PyObject * obj0 = 0 ;
42473 PyObject * obj1 = 0 ;
42474 PyObject * obj2 = 0 ;
42475 PyObject * obj3 = 0 ;
42476 PyObject * obj4 = 0 ;
42477 PyObject * obj5 = 0 ;
42478 char * kwnames[] = {
42479 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
42480 };
42481
42482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42483 if (obj0) {
42484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42485 if (!SWIG_IsOK(res1)) {
42486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42487 }
42488 arg1 = reinterpret_cast< wxMenu * >(argp1);
42489 }
42490 if (obj1) {
42491 ecode2 = SWIG_AsVal_int(obj1, &val2);
42492 if (!SWIG_IsOK(ecode2)) {
42493 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
42494 }
42495 arg2 = static_cast< int >(val2);
42496 }
42497 if (obj2) {
42498 {
42499 arg3 = wxString_in_helper(obj2);
42500 if (arg3 == NULL) SWIG_fail;
42501 temp3 = true;
42502 }
42503 }
42504 if (obj3) {
42505 {
42506 arg4 = wxString_in_helper(obj3);
42507 if (arg4 == NULL) SWIG_fail;
42508 temp4 = true;
42509 }
42510 }
42511 if (obj4) {
42512 ecode5 = SWIG_AsVal_int(obj4, &val5);
42513 if (!SWIG_IsOK(ecode5)) {
42514 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
42515 }
42516 arg5 = static_cast< wxItemKind >(val5);
42517 }
42518 if (obj5) {
42519 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
42520 if (!SWIG_IsOK(res6)) {
42521 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
42522 }
42523 arg6 = reinterpret_cast< wxMenu * >(argp6);
42524 }
42525 {
42526 PyThreadState* __tstate = wxPyBeginAllowThreads();
42527 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
42528 wxPyEndAllowThreads(__tstate);
42529 if (PyErr_Occurred()) SWIG_fail;
42530 }
42531 {
42532 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
42533 }
42534 {
42535 if (temp3)
42536 delete arg3;
42537 }
42538 {
42539 if (temp4)
42540 delete arg4;
42541 }
42542 return resultobj;
42543 fail:
42544 {
42545 if (temp3)
42546 delete arg3;
42547 }
42548 {
42549 if (temp4)
42550 delete arg4;
42551 }
42552 return NULL;
42553 }
42554
42555
42556 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42557 PyObject *resultobj = 0;
42558 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42559 void *argp1 = 0 ;
42560 int res1 = 0 ;
42561 PyObject *swig_obj[1] ;
42562
42563 if (!args) SWIG_fail;
42564 swig_obj[0] = args;
42565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42566 if (!SWIG_IsOK(res1)) {
42567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42568 }
42569 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42570 {
42571 PyThreadState* __tstate = wxPyBeginAllowThreads();
42572 delete arg1;
42573
42574 wxPyEndAllowThreads(__tstate);
42575 if (PyErr_Occurred()) SWIG_fail;
42576 }
42577 resultobj = SWIG_Py_Void();
42578 return resultobj;
42579 fail:
42580 return NULL;
42581 }
42582
42583
42584 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42585 PyObject *resultobj = 0;
42586 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42587 wxMenu *result = 0 ;
42588 void *argp1 = 0 ;
42589 int res1 = 0 ;
42590 PyObject *swig_obj[1] ;
42591
42592 if (!args) SWIG_fail;
42593 swig_obj[0] = args;
42594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42595 if (!SWIG_IsOK(res1)) {
42596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42597 }
42598 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42599 {
42600 PyThreadState* __tstate = wxPyBeginAllowThreads();
42601 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
42602 wxPyEndAllowThreads(__tstate);
42603 if (PyErr_Occurred()) SWIG_fail;
42604 }
42605 {
42606 resultobj = wxPyMake_wxObject(result, 0);
42607 }
42608 return resultobj;
42609 fail:
42610 return NULL;
42611 }
42612
42613
42614 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42615 PyObject *resultobj = 0;
42616 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42617 wxMenu *arg2 = (wxMenu *) 0 ;
42618 void *argp1 = 0 ;
42619 int res1 = 0 ;
42620 void *argp2 = 0 ;
42621 int res2 = 0 ;
42622 PyObject * obj0 = 0 ;
42623 PyObject * obj1 = 0 ;
42624 char * kwnames[] = {
42625 (char *) "self",(char *) "menu", NULL
42626 };
42627
42628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42630 if (!SWIG_IsOK(res1)) {
42631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42632 }
42633 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42634 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42635 if (!SWIG_IsOK(res2)) {
42636 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42637 }
42638 arg2 = reinterpret_cast< wxMenu * >(argp2);
42639 {
42640 PyThreadState* __tstate = wxPyBeginAllowThreads();
42641 (arg1)->SetMenu(arg2);
42642 wxPyEndAllowThreads(__tstate);
42643 if (PyErr_Occurred()) SWIG_fail;
42644 }
42645 resultobj = SWIG_Py_Void();
42646 return resultobj;
42647 fail:
42648 return NULL;
42649 }
42650
42651
42652 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42653 PyObject *resultobj = 0;
42654 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42655 int arg2 ;
42656 void *argp1 = 0 ;
42657 int res1 = 0 ;
42658 int val2 ;
42659 int ecode2 = 0 ;
42660 PyObject * obj0 = 0 ;
42661 PyObject * obj1 = 0 ;
42662 char * kwnames[] = {
42663 (char *) "self",(char *) "id", NULL
42664 };
42665
42666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
42667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42668 if (!SWIG_IsOK(res1)) {
42669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42670 }
42671 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42672 ecode2 = SWIG_AsVal_int(obj1, &val2);
42673 if (!SWIG_IsOK(ecode2)) {
42674 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
42675 }
42676 arg2 = static_cast< int >(val2);
42677 {
42678 PyThreadState* __tstate = wxPyBeginAllowThreads();
42679 (arg1)->SetId(arg2);
42680 wxPyEndAllowThreads(__tstate);
42681 if (PyErr_Occurred()) SWIG_fail;
42682 }
42683 resultobj = SWIG_Py_Void();
42684 return resultobj;
42685 fail:
42686 return NULL;
42687 }
42688
42689
42690 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42691 PyObject *resultobj = 0;
42692 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42693 int result;
42694 void *argp1 = 0 ;
42695 int res1 = 0 ;
42696 PyObject *swig_obj[1] ;
42697
42698 if (!args) SWIG_fail;
42699 swig_obj[0] = args;
42700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42701 if (!SWIG_IsOK(res1)) {
42702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42703 }
42704 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42705 {
42706 PyThreadState* __tstate = wxPyBeginAllowThreads();
42707 result = (int)((wxMenuItem const *)arg1)->GetId();
42708 wxPyEndAllowThreads(__tstate);
42709 if (PyErr_Occurred()) SWIG_fail;
42710 }
42711 resultobj = SWIG_From_int(static_cast< int >(result));
42712 return resultobj;
42713 fail:
42714 return NULL;
42715 }
42716
42717
42718 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42719 PyObject *resultobj = 0;
42720 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42721 bool result;
42722 void *argp1 = 0 ;
42723 int res1 = 0 ;
42724 PyObject *swig_obj[1] ;
42725
42726 if (!args) SWIG_fail;
42727 swig_obj[0] = args;
42728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42729 if (!SWIG_IsOK(res1)) {
42730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42731 }
42732 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42733 {
42734 PyThreadState* __tstate = wxPyBeginAllowThreads();
42735 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
42736 wxPyEndAllowThreads(__tstate);
42737 if (PyErr_Occurred()) SWIG_fail;
42738 }
42739 {
42740 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42741 }
42742 return resultobj;
42743 fail:
42744 return NULL;
42745 }
42746
42747
42748 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42749 PyObject *resultobj = 0;
42750 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42751 wxString *arg2 = 0 ;
42752 void *argp1 = 0 ;
42753 int res1 = 0 ;
42754 bool temp2 = false ;
42755 PyObject * obj0 = 0 ;
42756 PyObject * obj1 = 0 ;
42757 char * kwnames[] = {
42758 (char *) "self",(char *) "str", NULL
42759 };
42760
42761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
42762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42763 if (!SWIG_IsOK(res1)) {
42764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42765 }
42766 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42767 {
42768 arg2 = wxString_in_helper(obj1);
42769 if (arg2 == NULL) SWIG_fail;
42770 temp2 = true;
42771 }
42772 {
42773 PyThreadState* __tstate = wxPyBeginAllowThreads();
42774 (arg1)->SetText((wxString const &)*arg2);
42775 wxPyEndAllowThreads(__tstate);
42776 if (PyErr_Occurred()) SWIG_fail;
42777 }
42778 resultobj = SWIG_Py_Void();
42779 {
42780 if (temp2)
42781 delete arg2;
42782 }
42783 return resultobj;
42784 fail:
42785 {
42786 if (temp2)
42787 delete arg2;
42788 }
42789 return NULL;
42790 }
42791
42792
42793 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42794 PyObject *resultobj = 0;
42795 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42796 wxString result;
42797 void *argp1 = 0 ;
42798 int res1 = 0 ;
42799 PyObject *swig_obj[1] ;
42800
42801 if (!args) SWIG_fail;
42802 swig_obj[0] = args;
42803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42804 if (!SWIG_IsOK(res1)) {
42805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42806 }
42807 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42808 {
42809 PyThreadState* __tstate = wxPyBeginAllowThreads();
42810 result = ((wxMenuItem const *)arg1)->GetLabel();
42811 wxPyEndAllowThreads(__tstate);
42812 if (PyErr_Occurred()) SWIG_fail;
42813 }
42814 {
42815 #if wxUSE_UNICODE
42816 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42817 #else
42818 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42819 #endif
42820 }
42821 return resultobj;
42822 fail:
42823 return NULL;
42824 }
42825
42826
42827 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42828 PyObject *resultobj = 0;
42829 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42830 wxString *result = 0 ;
42831 void *argp1 = 0 ;
42832 int res1 = 0 ;
42833 PyObject *swig_obj[1] ;
42834
42835 if (!args) SWIG_fail;
42836 swig_obj[0] = args;
42837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42838 if (!SWIG_IsOK(res1)) {
42839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42840 }
42841 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42842 {
42843 PyThreadState* __tstate = wxPyBeginAllowThreads();
42844 {
42845 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
42846 result = (wxString *) &_result_ref;
42847 }
42848 wxPyEndAllowThreads(__tstate);
42849 if (PyErr_Occurred()) SWIG_fail;
42850 }
42851 {
42852 #if wxUSE_UNICODE
42853 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42854 #else
42855 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42856 #endif
42857 }
42858 return resultobj;
42859 fail:
42860 return NULL;
42861 }
42862
42863
42864 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42865 PyObject *resultobj = 0;
42866 wxString *arg1 = 0 ;
42867 wxString result;
42868 bool temp1 = false ;
42869 PyObject * obj0 = 0 ;
42870 char * kwnames[] = {
42871 (char *) "text", NULL
42872 };
42873
42874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
42875 {
42876 arg1 = wxString_in_helper(obj0);
42877 if (arg1 == NULL) SWIG_fail;
42878 temp1 = true;
42879 }
42880 {
42881 PyThreadState* __tstate = wxPyBeginAllowThreads();
42882 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
42883 wxPyEndAllowThreads(__tstate);
42884 if (PyErr_Occurred()) SWIG_fail;
42885 }
42886 {
42887 #if wxUSE_UNICODE
42888 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42889 #else
42890 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42891 #endif
42892 }
42893 {
42894 if (temp1)
42895 delete arg1;
42896 }
42897 return resultobj;
42898 fail:
42899 {
42900 if (temp1)
42901 delete arg1;
42902 }
42903 return NULL;
42904 }
42905
42906
42907 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42908 PyObject *resultobj = 0;
42909 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42910 wxItemKind result;
42911 void *argp1 = 0 ;
42912 int res1 = 0 ;
42913 PyObject *swig_obj[1] ;
42914
42915 if (!args) SWIG_fail;
42916 swig_obj[0] = args;
42917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42918 if (!SWIG_IsOK(res1)) {
42919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42920 }
42921 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42922 {
42923 PyThreadState* __tstate = wxPyBeginAllowThreads();
42924 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
42925 wxPyEndAllowThreads(__tstate);
42926 if (PyErr_Occurred()) SWIG_fail;
42927 }
42928 resultobj = SWIG_From_int(static_cast< int >(result));
42929 return resultobj;
42930 fail:
42931 return NULL;
42932 }
42933
42934
42935 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42936 PyObject *resultobj = 0;
42937 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42938 wxItemKind arg2 ;
42939 void *argp1 = 0 ;
42940 int res1 = 0 ;
42941 int val2 ;
42942 int ecode2 = 0 ;
42943 PyObject * obj0 = 0 ;
42944 PyObject * obj1 = 0 ;
42945 char * kwnames[] = {
42946 (char *) "self",(char *) "kind", NULL
42947 };
42948
42949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
42950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42951 if (!SWIG_IsOK(res1)) {
42952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42953 }
42954 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42955 ecode2 = SWIG_AsVal_int(obj1, &val2);
42956 if (!SWIG_IsOK(ecode2)) {
42957 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
42958 }
42959 arg2 = static_cast< wxItemKind >(val2);
42960 {
42961 PyThreadState* __tstate = wxPyBeginAllowThreads();
42962 (arg1)->SetKind(arg2);
42963 wxPyEndAllowThreads(__tstate);
42964 if (PyErr_Occurred()) SWIG_fail;
42965 }
42966 resultobj = SWIG_Py_Void();
42967 return resultobj;
42968 fail:
42969 return NULL;
42970 }
42971
42972
42973 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42974 PyObject *resultobj = 0;
42975 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42976 bool arg2 ;
42977 void *argp1 = 0 ;
42978 int res1 = 0 ;
42979 bool val2 ;
42980 int ecode2 = 0 ;
42981 PyObject * obj0 = 0 ;
42982 PyObject * obj1 = 0 ;
42983 char * kwnames[] = {
42984 (char *) "self",(char *) "checkable", NULL
42985 };
42986
42987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
42988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42989 if (!SWIG_IsOK(res1)) {
42990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42991 }
42992 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42993 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42994 if (!SWIG_IsOK(ecode2)) {
42995 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
42996 }
42997 arg2 = static_cast< bool >(val2);
42998 {
42999 PyThreadState* __tstate = wxPyBeginAllowThreads();
43000 (arg1)->SetCheckable(arg2);
43001 wxPyEndAllowThreads(__tstate);
43002 if (PyErr_Occurred()) SWIG_fail;
43003 }
43004 resultobj = SWIG_Py_Void();
43005 return resultobj;
43006 fail:
43007 return NULL;
43008 }
43009
43010
43011 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43012 PyObject *resultobj = 0;
43013 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43014 bool result;
43015 void *argp1 = 0 ;
43016 int res1 = 0 ;
43017 PyObject *swig_obj[1] ;
43018
43019 if (!args) SWIG_fail;
43020 swig_obj[0] = args;
43021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43022 if (!SWIG_IsOK(res1)) {
43023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43024 }
43025 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43026 {
43027 PyThreadState* __tstate = wxPyBeginAllowThreads();
43028 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
43029 wxPyEndAllowThreads(__tstate);
43030 if (PyErr_Occurred()) SWIG_fail;
43031 }
43032 {
43033 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43034 }
43035 return resultobj;
43036 fail:
43037 return NULL;
43038 }
43039
43040
43041 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43042 PyObject *resultobj = 0;
43043 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43044 bool result;
43045 void *argp1 = 0 ;
43046 int res1 = 0 ;
43047 PyObject *swig_obj[1] ;
43048
43049 if (!args) SWIG_fail;
43050 swig_obj[0] = args;
43051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43052 if (!SWIG_IsOK(res1)) {
43053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43054 }
43055 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43056 {
43057 PyThreadState* __tstate = wxPyBeginAllowThreads();
43058 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
43059 wxPyEndAllowThreads(__tstate);
43060 if (PyErr_Occurred()) SWIG_fail;
43061 }
43062 {
43063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43064 }
43065 return resultobj;
43066 fail:
43067 return NULL;
43068 }
43069
43070
43071 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43072 PyObject *resultobj = 0;
43073 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43074 wxMenu *arg2 = (wxMenu *) 0 ;
43075 void *argp1 = 0 ;
43076 int res1 = 0 ;
43077 void *argp2 = 0 ;
43078 int res2 = 0 ;
43079 PyObject * obj0 = 0 ;
43080 PyObject * obj1 = 0 ;
43081 char * kwnames[] = {
43082 (char *) "self",(char *) "menu", NULL
43083 };
43084
43085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
43086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43087 if (!SWIG_IsOK(res1)) {
43088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43089 }
43090 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43091 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
43092 if (!SWIG_IsOK(res2)) {
43093 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
43094 }
43095 arg2 = reinterpret_cast< wxMenu * >(argp2);
43096 {
43097 PyThreadState* __tstate = wxPyBeginAllowThreads();
43098 (arg1)->SetSubMenu(arg2);
43099 wxPyEndAllowThreads(__tstate);
43100 if (PyErr_Occurred()) SWIG_fail;
43101 }
43102 resultobj = SWIG_Py_Void();
43103 return resultobj;
43104 fail:
43105 return NULL;
43106 }
43107
43108
43109 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43110 PyObject *resultobj = 0;
43111 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43112 wxMenu *result = 0 ;
43113 void *argp1 = 0 ;
43114 int res1 = 0 ;
43115 PyObject *swig_obj[1] ;
43116
43117 if (!args) SWIG_fail;
43118 swig_obj[0] = args;
43119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43120 if (!SWIG_IsOK(res1)) {
43121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43122 }
43123 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43124 {
43125 PyThreadState* __tstate = wxPyBeginAllowThreads();
43126 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
43127 wxPyEndAllowThreads(__tstate);
43128 if (PyErr_Occurred()) SWIG_fail;
43129 }
43130 {
43131 resultobj = wxPyMake_wxObject(result, 0);
43132 }
43133 return resultobj;
43134 fail:
43135 return NULL;
43136 }
43137
43138
43139 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43140 PyObject *resultobj = 0;
43141 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43142 bool arg2 = (bool) true ;
43143 void *argp1 = 0 ;
43144 int res1 = 0 ;
43145 bool val2 ;
43146 int ecode2 = 0 ;
43147 PyObject * obj0 = 0 ;
43148 PyObject * obj1 = 0 ;
43149 char * kwnames[] = {
43150 (char *) "self",(char *) "enable", NULL
43151 };
43152
43153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
43154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43155 if (!SWIG_IsOK(res1)) {
43156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43157 }
43158 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43159 if (obj1) {
43160 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43161 if (!SWIG_IsOK(ecode2)) {
43162 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
43163 }
43164 arg2 = static_cast< bool >(val2);
43165 }
43166 {
43167 PyThreadState* __tstate = wxPyBeginAllowThreads();
43168 (arg1)->Enable(arg2);
43169 wxPyEndAllowThreads(__tstate);
43170 if (PyErr_Occurred()) SWIG_fail;
43171 }
43172 resultobj = SWIG_Py_Void();
43173 return resultobj;
43174 fail:
43175 return NULL;
43176 }
43177
43178
43179 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43180 PyObject *resultobj = 0;
43181 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43182 bool result;
43183 void *argp1 = 0 ;
43184 int res1 = 0 ;
43185 PyObject *swig_obj[1] ;
43186
43187 if (!args) SWIG_fail;
43188 swig_obj[0] = args;
43189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43190 if (!SWIG_IsOK(res1)) {
43191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43192 }
43193 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43194 {
43195 PyThreadState* __tstate = wxPyBeginAllowThreads();
43196 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
43197 wxPyEndAllowThreads(__tstate);
43198 if (PyErr_Occurred()) SWIG_fail;
43199 }
43200 {
43201 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43202 }
43203 return resultobj;
43204 fail:
43205 return NULL;
43206 }
43207
43208
43209 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43210 PyObject *resultobj = 0;
43211 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43212 bool arg2 = (bool) true ;
43213 void *argp1 = 0 ;
43214 int res1 = 0 ;
43215 bool val2 ;
43216 int ecode2 = 0 ;
43217 PyObject * obj0 = 0 ;
43218 PyObject * obj1 = 0 ;
43219 char * kwnames[] = {
43220 (char *) "self",(char *) "check", NULL
43221 };
43222
43223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
43224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43225 if (!SWIG_IsOK(res1)) {
43226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43227 }
43228 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43229 if (obj1) {
43230 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43231 if (!SWIG_IsOK(ecode2)) {
43232 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
43233 }
43234 arg2 = static_cast< bool >(val2);
43235 }
43236 {
43237 PyThreadState* __tstate = wxPyBeginAllowThreads();
43238 (arg1)->Check(arg2);
43239 wxPyEndAllowThreads(__tstate);
43240 if (PyErr_Occurred()) SWIG_fail;
43241 }
43242 resultobj = SWIG_Py_Void();
43243 return resultobj;
43244 fail:
43245 return NULL;
43246 }
43247
43248
43249 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43250 PyObject *resultobj = 0;
43251 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43252 bool result;
43253 void *argp1 = 0 ;
43254 int res1 = 0 ;
43255 PyObject *swig_obj[1] ;
43256
43257 if (!args) SWIG_fail;
43258 swig_obj[0] = args;
43259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43260 if (!SWIG_IsOK(res1)) {
43261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43262 }
43263 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43264 {
43265 PyThreadState* __tstate = wxPyBeginAllowThreads();
43266 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
43267 wxPyEndAllowThreads(__tstate);
43268 if (PyErr_Occurred()) SWIG_fail;
43269 }
43270 {
43271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43272 }
43273 return resultobj;
43274 fail:
43275 return NULL;
43276 }
43277
43278
43279 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43280 PyObject *resultobj = 0;
43281 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43282 void *argp1 = 0 ;
43283 int res1 = 0 ;
43284 PyObject *swig_obj[1] ;
43285
43286 if (!args) SWIG_fail;
43287 swig_obj[0] = args;
43288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43289 if (!SWIG_IsOK(res1)) {
43290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43291 }
43292 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43293 {
43294 PyThreadState* __tstate = wxPyBeginAllowThreads();
43295 (arg1)->Toggle();
43296 wxPyEndAllowThreads(__tstate);
43297 if (PyErr_Occurred()) SWIG_fail;
43298 }
43299 resultobj = SWIG_Py_Void();
43300 return resultobj;
43301 fail:
43302 return NULL;
43303 }
43304
43305
43306 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43307 PyObject *resultobj = 0;
43308 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43309 wxString *arg2 = 0 ;
43310 void *argp1 = 0 ;
43311 int res1 = 0 ;
43312 bool temp2 = false ;
43313 PyObject * obj0 = 0 ;
43314 PyObject * obj1 = 0 ;
43315 char * kwnames[] = {
43316 (char *) "self",(char *) "str", NULL
43317 };
43318
43319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
43320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43321 if (!SWIG_IsOK(res1)) {
43322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43323 }
43324 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43325 {
43326 arg2 = wxString_in_helper(obj1);
43327 if (arg2 == NULL) SWIG_fail;
43328 temp2 = true;
43329 }
43330 {
43331 PyThreadState* __tstate = wxPyBeginAllowThreads();
43332 (arg1)->SetHelp((wxString const &)*arg2);
43333 wxPyEndAllowThreads(__tstate);
43334 if (PyErr_Occurred()) SWIG_fail;
43335 }
43336 resultobj = SWIG_Py_Void();
43337 {
43338 if (temp2)
43339 delete arg2;
43340 }
43341 return resultobj;
43342 fail:
43343 {
43344 if (temp2)
43345 delete arg2;
43346 }
43347 return NULL;
43348 }
43349
43350
43351 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43352 PyObject *resultobj = 0;
43353 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43354 wxString *result = 0 ;
43355 void *argp1 = 0 ;
43356 int res1 = 0 ;
43357 PyObject *swig_obj[1] ;
43358
43359 if (!args) SWIG_fail;
43360 swig_obj[0] = args;
43361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43362 if (!SWIG_IsOK(res1)) {
43363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43364 }
43365 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43366 {
43367 PyThreadState* __tstate = wxPyBeginAllowThreads();
43368 {
43369 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
43370 result = (wxString *) &_result_ref;
43371 }
43372 wxPyEndAllowThreads(__tstate);
43373 if (PyErr_Occurred()) SWIG_fail;
43374 }
43375 {
43376 #if wxUSE_UNICODE
43377 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43378 #else
43379 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43380 #endif
43381 }
43382 return resultobj;
43383 fail:
43384 return NULL;
43385 }
43386
43387
43388 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43389 PyObject *resultobj = 0;
43390 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43391 wxAcceleratorEntry *result = 0 ;
43392 void *argp1 = 0 ;
43393 int res1 = 0 ;
43394 PyObject *swig_obj[1] ;
43395
43396 if (!args) SWIG_fail;
43397 swig_obj[0] = args;
43398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43399 if (!SWIG_IsOK(res1)) {
43400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43401 }
43402 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43403 {
43404 PyThreadState* __tstate = wxPyBeginAllowThreads();
43405 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
43406 wxPyEndAllowThreads(__tstate);
43407 if (PyErr_Occurred()) SWIG_fail;
43408 }
43409 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43410 return resultobj;
43411 fail:
43412 return NULL;
43413 }
43414
43415
43416 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43417 PyObject *resultobj = 0;
43418 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43419 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
43420 void *argp1 = 0 ;
43421 int res1 = 0 ;
43422 void *argp2 = 0 ;
43423 int res2 = 0 ;
43424 PyObject * obj0 = 0 ;
43425 PyObject * obj1 = 0 ;
43426 char * kwnames[] = {
43427 (char *) "self",(char *) "accel", NULL
43428 };
43429
43430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
43431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43432 if (!SWIG_IsOK(res1)) {
43433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43434 }
43435 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43436 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43437 if (!SWIG_IsOK(res2)) {
43438 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
43439 }
43440 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
43441 {
43442 PyThreadState* __tstate = wxPyBeginAllowThreads();
43443 (arg1)->SetAccel(arg2);
43444 wxPyEndAllowThreads(__tstate);
43445 if (PyErr_Occurred()) SWIG_fail;
43446 }
43447 resultobj = SWIG_Py_Void();
43448 return resultobj;
43449 fail:
43450 return NULL;
43451 }
43452
43453
43454 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43455 PyObject *resultobj = 0;
43456 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43457 wxBitmap *arg2 = 0 ;
43458 void *argp1 = 0 ;
43459 int res1 = 0 ;
43460 void *argp2 = 0 ;
43461 int res2 = 0 ;
43462 PyObject * obj0 = 0 ;
43463 PyObject * obj1 = 0 ;
43464 char * kwnames[] = {
43465 (char *) "self",(char *) "bitmap", NULL
43466 };
43467
43468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43470 if (!SWIG_IsOK(res1)) {
43471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43472 }
43473 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43474 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43475 if (!SWIG_IsOK(res2)) {
43476 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43477 }
43478 if (!argp2) {
43479 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43480 }
43481 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43482 {
43483 PyThreadState* __tstate = wxPyBeginAllowThreads();
43484 (arg1)->SetBitmap((wxBitmap const &)*arg2);
43485 wxPyEndAllowThreads(__tstate);
43486 if (PyErr_Occurred()) SWIG_fail;
43487 }
43488 resultobj = SWIG_Py_Void();
43489 return resultobj;
43490 fail:
43491 return NULL;
43492 }
43493
43494
43495 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43496 PyObject *resultobj = 0;
43497 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43498 wxBitmap *result = 0 ;
43499 void *argp1 = 0 ;
43500 int res1 = 0 ;
43501 PyObject *swig_obj[1] ;
43502
43503 if (!args) SWIG_fail;
43504 swig_obj[0] = args;
43505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43506 if (!SWIG_IsOK(res1)) {
43507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43508 }
43509 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43510 {
43511 PyThreadState* __tstate = wxPyBeginAllowThreads();
43512 {
43513 wxBitmap const &_result_ref = (arg1)->GetBitmap();
43514 result = (wxBitmap *) &_result_ref;
43515 }
43516 wxPyEndAllowThreads(__tstate);
43517 if (PyErr_Occurred()) SWIG_fail;
43518 }
43519 {
43520 wxBitmap* resultptr = new wxBitmap(*result);
43521 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43522 }
43523 return resultobj;
43524 fail:
43525 return NULL;
43526 }
43527
43528
43529 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43530 PyObject *resultobj = 0;
43531 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43532 wxFont *arg2 = 0 ;
43533 void *argp1 = 0 ;
43534 int res1 = 0 ;
43535 void *argp2 = 0 ;
43536 int res2 = 0 ;
43537 PyObject * obj0 = 0 ;
43538 PyObject * obj1 = 0 ;
43539 char * kwnames[] = {
43540 (char *) "self",(char *) "font", NULL
43541 };
43542
43543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
43544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43545 if (!SWIG_IsOK(res1)) {
43546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43547 }
43548 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43549 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
43550 if (!SWIG_IsOK(res2)) {
43551 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43552 }
43553 if (!argp2) {
43554 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43555 }
43556 arg2 = reinterpret_cast< wxFont * >(argp2);
43557 {
43558 PyThreadState* __tstate = wxPyBeginAllowThreads();
43559 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
43560 wxPyEndAllowThreads(__tstate);
43561 if (PyErr_Occurred()) SWIG_fail;
43562 }
43563 resultobj = SWIG_Py_Void();
43564 return resultobj;
43565 fail:
43566 return NULL;
43567 }
43568
43569
43570 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43571 PyObject *resultobj = 0;
43572 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43573 wxFont result;
43574 void *argp1 = 0 ;
43575 int res1 = 0 ;
43576 PyObject *swig_obj[1] ;
43577
43578 if (!args) SWIG_fail;
43579 swig_obj[0] = args;
43580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43581 if (!SWIG_IsOK(res1)) {
43582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43583 }
43584 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43585 {
43586 PyThreadState* __tstate = wxPyBeginAllowThreads();
43587 result = wxMenuItem_GetFont(arg1);
43588 wxPyEndAllowThreads(__tstate);
43589 if (PyErr_Occurred()) SWIG_fail;
43590 }
43591 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
43592 return resultobj;
43593 fail:
43594 return NULL;
43595 }
43596
43597
43598 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43599 PyObject *resultobj = 0;
43600 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43601 wxColour *arg2 = 0 ;
43602 void *argp1 = 0 ;
43603 int res1 = 0 ;
43604 wxColour temp2 ;
43605 PyObject * obj0 = 0 ;
43606 PyObject * obj1 = 0 ;
43607 char * kwnames[] = {
43608 (char *) "self",(char *) "colText", NULL
43609 };
43610
43611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
43612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43613 if (!SWIG_IsOK(res1)) {
43614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43615 }
43616 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43617 {
43618 arg2 = &temp2;
43619 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43620 }
43621 {
43622 PyThreadState* __tstate = wxPyBeginAllowThreads();
43623 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
43624 wxPyEndAllowThreads(__tstate);
43625 if (PyErr_Occurred()) SWIG_fail;
43626 }
43627 resultobj = SWIG_Py_Void();
43628 return resultobj;
43629 fail:
43630 return NULL;
43631 }
43632
43633
43634 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43635 PyObject *resultobj = 0;
43636 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43637 wxColour result;
43638 void *argp1 = 0 ;
43639 int res1 = 0 ;
43640 PyObject *swig_obj[1] ;
43641
43642 if (!args) SWIG_fail;
43643 swig_obj[0] = args;
43644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43645 if (!SWIG_IsOK(res1)) {
43646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43647 }
43648 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43649 {
43650 PyThreadState* __tstate = wxPyBeginAllowThreads();
43651 result = wxMenuItem_GetTextColour(arg1);
43652 wxPyEndAllowThreads(__tstate);
43653 if (PyErr_Occurred()) SWIG_fail;
43654 }
43655 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43656 return resultobj;
43657 fail:
43658 return NULL;
43659 }
43660
43661
43662 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43663 PyObject *resultobj = 0;
43664 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43665 wxColour *arg2 = 0 ;
43666 void *argp1 = 0 ;
43667 int res1 = 0 ;
43668 wxColour temp2 ;
43669 PyObject * obj0 = 0 ;
43670 PyObject * obj1 = 0 ;
43671 char * kwnames[] = {
43672 (char *) "self",(char *) "colBack", NULL
43673 };
43674
43675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
43676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43677 if (!SWIG_IsOK(res1)) {
43678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43679 }
43680 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43681 {
43682 arg2 = &temp2;
43683 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43684 }
43685 {
43686 PyThreadState* __tstate = wxPyBeginAllowThreads();
43687 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
43688 wxPyEndAllowThreads(__tstate);
43689 if (PyErr_Occurred()) SWIG_fail;
43690 }
43691 resultobj = SWIG_Py_Void();
43692 return resultobj;
43693 fail:
43694 return NULL;
43695 }
43696
43697
43698 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43699 PyObject *resultobj = 0;
43700 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43701 wxColour result;
43702 void *argp1 = 0 ;
43703 int res1 = 0 ;
43704 PyObject *swig_obj[1] ;
43705
43706 if (!args) SWIG_fail;
43707 swig_obj[0] = args;
43708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43709 if (!SWIG_IsOK(res1)) {
43710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43711 }
43712 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43713 {
43714 PyThreadState* __tstate = wxPyBeginAllowThreads();
43715 result = wxMenuItem_GetBackgroundColour(arg1);
43716 wxPyEndAllowThreads(__tstate);
43717 if (PyErr_Occurred()) SWIG_fail;
43718 }
43719 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43720 return resultobj;
43721 fail:
43722 return NULL;
43723 }
43724
43725
43726 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43727 PyObject *resultobj = 0;
43728 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43729 wxBitmap *arg2 = 0 ;
43730 wxBitmap const &arg3_defvalue = wxNullBitmap ;
43731 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
43732 void *argp1 = 0 ;
43733 int res1 = 0 ;
43734 void *argp2 = 0 ;
43735 int res2 = 0 ;
43736 void *argp3 = 0 ;
43737 int res3 = 0 ;
43738 PyObject * obj0 = 0 ;
43739 PyObject * obj1 = 0 ;
43740 PyObject * obj2 = 0 ;
43741 char * kwnames[] = {
43742 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
43743 };
43744
43745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43747 if (!SWIG_IsOK(res1)) {
43748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43749 }
43750 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43751 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43752 if (!SWIG_IsOK(res2)) {
43753 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43754 }
43755 if (!argp2) {
43756 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43757 }
43758 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43759 if (obj2) {
43760 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
43761 if (!SWIG_IsOK(res3)) {
43762 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43763 }
43764 if (!argp3) {
43765 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43766 }
43767 arg3 = reinterpret_cast< wxBitmap * >(argp3);
43768 }
43769 {
43770 PyThreadState* __tstate = wxPyBeginAllowThreads();
43771 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
43772 wxPyEndAllowThreads(__tstate);
43773 if (PyErr_Occurred()) SWIG_fail;
43774 }
43775 resultobj = SWIG_Py_Void();
43776 return resultobj;
43777 fail:
43778 return NULL;
43779 }
43780
43781
43782 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43783 PyObject *resultobj = 0;
43784 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43785 wxBitmap *arg2 = 0 ;
43786 void *argp1 = 0 ;
43787 int res1 = 0 ;
43788 void *argp2 = 0 ;
43789 int res2 = 0 ;
43790 PyObject * obj0 = 0 ;
43791 PyObject * obj1 = 0 ;
43792 char * kwnames[] = {
43793 (char *) "self",(char *) "bmpDisabled", NULL
43794 };
43795
43796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43798 if (!SWIG_IsOK(res1)) {
43799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43800 }
43801 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43802 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43803 if (!SWIG_IsOK(res2)) {
43804 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43805 }
43806 if (!argp2) {
43807 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43808 }
43809 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43810 {
43811 PyThreadState* __tstate = wxPyBeginAllowThreads();
43812 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
43813 wxPyEndAllowThreads(__tstate);
43814 if (PyErr_Occurred()) SWIG_fail;
43815 }
43816 resultobj = SWIG_Py_Void();
43817 return resultobj;
43818 fail:
43819 return NULL;
43820 }
43821
43822
43823 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43824 PyObject *resultobj = 0;
43825 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43826 wxBitmap *result = 0 ;
43827 void *argp1 = 0 ;
43828 int res1 = 0 ;
43829 PyObject *swig_obj[1] ;
43830
43831 if (!args) SWIG_fail;
43832 swig_obj[0] = args;
43833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43834 if (!SWIG_IsOK(res1)) {
43835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43836 }
43837 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43838 {
43839 PyThreadState* __tstate = wxPyBeginAllowThreads();
43840 {
43841 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
43842 result = (wxBitmap *) &_result_ref;
43843 }
43844 wxPyEndAllowThreads(__tstate);
43845 if (PyErr_Occurred()) SWIG_fail;
43846 }
43847 {
43848 wxBitmap* resultptr = new wxBitmap(*result);
43849 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43850 }
43851 return resultobj;
43852 fail:
43853 return NULL;
43854 }
43855
43856
43857 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43858 PyObject *resultobj = 0;
43859 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43860 int arg2 ;
43861 void *argp1 = 0 ;
43862 int res1 = 0 ;
43863 int val2 ;
43864 int ecode2 = 0 ;
43865 PyObject * obj0 = 0 ;
43866 PyObject * obj1 = 0 ;
43867 char * kwnames[] = {
43868 (char *) "self",(char *) "nWidth", NULL
43869 };
43870
43871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
43872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43873 if (!SWIG_IsOK(res1)) {
43874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43875 }
43876 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43877 ecode2 = SWIG_AsVal_int(obj1, &val2);
43878 if (!SWIG_IsOK(ecode2)) {
43879 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
43880 }
43881 arg2 = static_cast< int >(val2);
43882 {
43883 PyThreadState* __tstate = wxPyBeginAllowThreads();
43884 wxMenuItem_SetMarginWidth(arg1,arg2);
43885 wxPyEndAllowThreads(__tstate);
43886 if (PyErr_Occurred()) SWIG_fail;
43887 }
43888 resultobj = SWIG_Py_Void();
43889 return resultobj;
43890 fail:
43891 return NULL;
43892 }
43893
43894
43895 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43896 PyObject *resultobj = 0;
43897 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43898 int result;
43899 void *argp1 = 0 ;
43900 int res1 = 0 ;
43901 PyObject *swig_obj[1] ;
43902
43903 if (!args) SWIG_fail;
43904 swig_obj[0] = args;
43905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43906 if (!SWIG_IsOK(res1)) {
43907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43908 }
43909 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43910 {
43911 PyThreadState* __tstate = wxPyBeginAllowThreads();
43912 result = (int)wxMenuItem_GetMarginWidth(arg1);
43913 wxPyEndAllowThreads(__tstate);
43914 if (PyErr_Occurred()) SWIG_fail;
43915 }
43916 resultobj = SWIG_From_int(static_cast< int >(result));
43917 return resultobj;
43918 fail:
43919 return NULL;
43920 }
43921
43922
43923 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43924 PyObject *resultobj = 0;
43925 int result;
43926
43927 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
43928 {
43929 PyThreadState* __tstate = wxPyBeginAllowThreads();
43930 result = (int)wxMenuItem_GetDefaultMarginWidth();
43931 wxPyEndAllowThreads(__tstate);
43932 if (PyErr_Occurred()) SWIG_fail;
43933 }
43934 resultobj = SWIG_From_int(static_cast< int >(result));
43935 return resultobj;
43936 fail:
43937 return NULL;
43938 }
43939
43940
43941 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43942 PyObject *resultobj = 0;
43943 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43944 bool result;
43945 void *argp1 = 0 ;
43946 int res1 = 0 ;
43947 PyObject *swig_obj[1] ;
43948
43949 if (!args) SWIG_fail;
43950 swig_obj[0] = args;
43951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43952 if (!SWIG_IsOK(res1)) {
43953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43954 }
43955 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43956 {
43957 PyThreadState* __tstate = wxPyBeginAllowThreads();
43958 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
43959 wxPyEndAllowThreads(__tstate);
43960 if (PyErr_Occurred()) SWIG_fail;
43961 }
43962 {
43963 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43964 }
43965 return resultobj;
43966 fail:
43967 return NULL;
43968 }
43969
43970
43971 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43972 PyObject *resultobj = 0;
43973 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43974 bool arg2 = (bool) true ;
43975 void *argp1 = 0 ;
43976 int res1 = 0 ;
43977 bool val2 ;
43978 int ecode2 = 0 ;
43979 PyObject * obj0 = 0 ;
43980 PyObject * obj1 = 0 ;
43981 char * kwnames[] = {
43982 (char *) "self",(char *) "ownerDrawn", NULL
43983 };
43984
43985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
43986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43987 if (!SWIG_IsOK(res1)) {
43988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43989 }
43990 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43991 if (obj1) {
43992 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43993 if (!SWIG_IsOK(ecode2)) {
43994 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
43995 }
43996 arg2 = static_cast< bool >(val2);
43997 }
43998 {
43999 PyThreadState* __tstate = wxPyBeginAllowThreads();
44000 wxMenuItem_SetOwnerDrawn(arg1,arg2);
44001 wxPyEndAllowThreads(__tstate);
44002 if (PyErr_Occurred()) SWIG_fail;
44003 }
44004 resultobj = SWIG_Py_Void();
44005 return resultobj;
44006 fail:
44007 return NULL;
44008 }
44009
44010
44011 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44012 PyObject *resultobj = 0;
44013 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44014 void *argp1 = 0 ;
44015 int res1 = 0 ;
44016 PyObject *swig_obj[1] ;
44017
44018 if (!args) SWIG_fail;
44019 swig_obj[0] = args;
44020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44021 if (!SWIG_IsOK(res1)) {
44022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44023 }
44024 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44025 {
44026 PyThreadState* __tstate = wxPyBeginAllowThreads();
44027 wxMenuItem_ResetOwnerDrawn(arg1);
44028 wxPyEndAllowThreads(__tstate);
44029 if (PyErr_Occurred()) SWIG_fail;
44030 }
44031 resultobj = SWIG_Py_Void();
44032 return resultobj;
44033 fail:
44034 return NULL;
44035 }
44036
44037
44038 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44039 PyObject *obj;
44040 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44041 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
44042 return SWIG_Py_Void();
44043 }
44044
44045 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44046 return SWIG_Python_InitShadowInstance(args);
44047 }
44048
44049 SWIGINTERN int ControlNameStr_set(PyObject *) {
44050 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
44051 return 1;
44052 }
44053
44054
44055 SWIGINTERN PyObject *ControlNameStr_get(void) {
44056 PyObject *pyobj = 0;
44057
44058 {
44059 #if wxUSE_UNICODE
44060 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
44061 #else
44062 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
44063 #endif
44064 }
44065 return pyobj;
44066 }
44067
44068
44069 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44070 PyObject *resultobj = 0;
44071 wxWindow *arg1 = (wxWindow *) 0 ;
44072 int arg2 = (int) -1 ;
44073 wxPoint const &arg3_defvalue = wxDefaultPosition ;
44074 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
44075 wxSize const &arg4_defvalue = wxDefaultSize ;
44076 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
44077 long arg5 = (long) 0 ;
44078 wxValidator const &arg6_defvalue = wxDefaultValidator ;
44079 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
44080 wxString const &arg7_defvalue = wxPyControlNameStr ;
44081 wxString *arg7 = (wxString *) &arg7_defvalue ;
44082 wxControl *result = 0 ;
44083 void *argp1 = 0 ;
44084 int res1 = 0 ;
44085 int val2 ;
44086 int ecode2 = 0 ;
44087 wxPoint temp3 ;
44088 wxSize temp4 ;
44089 long val5 ;
44090 int ecode5 = 0 ;
44091 void *argp6 = 0 ;
44092 int res6 = 0 ;
44093 bool temp7 = false ;
44094 PyObject * obj0 = 0 ;
44095 PyObject * obj1 = 0 ;
44096 PyObject * obj2 = 0 ;
44097 PyObject * obj3 = 0 ;
44098 PyObject * obj4 = 0 ;
44099 PyObject * obj5 = 0 ;
44100 PyObject * obj6 = 0 ;
44101 char * kwnames[] = {
44102 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
44103 };
44104
44105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
44106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
44107 if (!SWIG_IsOK(res1)) {
44108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
44109 }
44110 arg1 = reinterpret_cast< wxWindow * >(argp1);
44111 if (obj1) {
44112 ecode2 = SWIG_AsVal_int(obj1, &val2);
44113 if (!SWIG_IsOK(ecode2)) {
44114 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
44115 }
44116 arg2 = static_cast< int >(val2);
44117 }
44118 if (obj2) {
44119 {
44120 arg3 = &temp3;
44121 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
44122 }
44123 }
44124 if (obj3) {
44125 {
44126 arg4 = &temp4;
44127 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
44128 }
44129 }
44130 if (obj4) {
44131 ecode5 = SWIG_AsVal_long(obj4, &val5);
44132 if (!SWIG_IsOK(ecode5)) {
44133 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
44134 }
44135 arg5 = static_cast< long >(val5);
44136 }
44137 if (obj5) {
44138 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
44139 if (!SWIG_IsOK(res6)) {
44140 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
44141 }
44142 if (!argp6) {
44143 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
44144 }
44145 arg6 = reinterpret_cast< wxValidator * >(argp6);
44146 }
44147 if (obj6) {
44148 {
44149 arg7 = wxString_in_helper(obj6);
44150 if (arg7 == NULL) SWIG_fail;
44151 temp7 = true;
44152 }
44153 }
44154 {
44155 if (!wxPyCheckForApp()) SWIG_fail;
44156 PyThreadState* __tstate = wxPyBeginAllowThreads();
44157 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
44158 wxPyEndAllowThreads(__tstate);
44159 if (PyErr_Occurred()) SWIG_fail;
44160 }
44161 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
44162 {
44163 if (temp7)
44164 delete arg7;
44165 }
44166 return resultobj;
44167 fail:
44168 {
44169 if (temp7)
44170 delete arg7;
44171 }
44172 return NULL;
44173 }
44174
44175
44176 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44177 PyObject *resultobj = 0;
44178 wxControl *result = 0 ;
44179
44180 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
44181 {
44182 if (!wxPyCheckForApp()) SWIG_fail;
44183 PyThreadState* __tstate = wxPyBeginAllowThreads();
44184 result = (wxControl *)new wxControl();
44185 wxPyEndAllowThreads(__tstate);
44186 if (PyErr_Occurred()) SWIG_fail;
44187 }
44188 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
44189 return resultobj;
44190 fail:
44191 return NULL;
44192 }
44193
44194
44195 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44196 PyObject *resultobj = 0;
44197 wxControl *arg1 = (wxControl *) 0 ;
44198 wxWindow *arg2 = (wxWindow *) 0 ;
44199 int arg3 = (int) -1 ;
44200 wxPoint const &arg4_defvalue = wxDefaultPosition ;
44201 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
44202 wxSize const &arg5_defvalue = wxDefaultSize ;
44203 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
44204 long arg6 = (long) 0 ;
44205 wxValidator const &arg7_defvalue = wxDefaultValidator ;
44206 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
44207 wxString const &arg8_defvalue = wxPyControlNameStr ;
44208 wxString *arg8 = (wxString *) &arg8_defvalue ;
44209 bool result;
44210 void *argp1 = 0 ;
44211 int res1 = 0 ;
44212 void *argp2 = 0 ;
44213 int res2 = 0 ;
44214 int val3 ;
44215 int ecode3 = 0 ;
44216 wxPoint temp4 ;
44217 wxSize temp5 ;
44218 long val6 ;
44219 int ecode6 = 0 ;
44220 void *argp7 = 0 ;
44221 int res7 = 0 ;
44222 bool temp8 = false ;
44223 PyObject * obj0 = 0 ;
44224 PyObject * obj1 = 0 ;
44225 PyObject * obj2 = 0 ;
44226 PyObject * obj3 = 0 ;
44227 PyObject * obj4 = 0 ;
44228 PyObject * obj5 = 0 ;
44229 PyObject * obj6 = 0 ;
44230 PyObject * obj7 = 0 ;
44231 char * kwnames[] = {
44232 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
44233 };
44234
44235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
44236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44237 if (!SWIG_IsOK(res1)) {
44238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
44239 }
44240 arg1 = reinterpret_cast< wxControl * >(argp1);
44241 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
44242 if (!SWIG_IsOK(res2)) {
44243 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
44244 }
44245 arg2 = reinterpret_cast< wxWindow * >(argp2);
44246 if (obj2) {
44247 ecode3 = SWIG_AsVal_int(obj2, &val3);
44248 if (!SWIG_IsOK(ecode3)) {
44249 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
44250 }
44251 arg3 = static_cast< int >(val3);
44252 }
44253 if (obj3) {
44254 {
44255 arg4 = &temp4;
44256 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
44257 }
44258 }
44259 if (obj4) {
44260 {
44261 arg5 = &temp5;
44262 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
44263 }
44264 }
44265 if (obj5) {
44266 ecode6 = SWIG_AsVal_long(obj5, &val6);
44267 if (!SWIG_IsOK(ecode6)) {
44268 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
44269 }
44270 arg6 = static_cast< long >(val6);
44271 }
44272 if (obj6) {
44273 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
44274 if (!SWIG_IsOK(res7)) {
44275 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44276 }
44277 if (!argp7) {
44278 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44279 }
44280 arg7 = reinterpret_cast< wxValidator * >(argp7);
44281 }
44282 if (obj7) {
44283 {
44284 arg8 = wxString_in_helper(obj7);
44285 if (arg8 == NULL) SWIG_fail;
44286 temp8 = true;
44287 }
44288 }
44289 {
44290 PyThreadState* __tstate = wxPyBeginAllowThreads();
44291 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
44292 wxPyEndAllowThreads(__tstate);
44293 if (PyErr_Occurred()) SWIG_fail;
44294 }
44295 {
44296 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44297 }
44298 {
44299 if (temp8)
44300 delete arg8;
44301 }
44302 return resultobj;
44303 fail:
44304 {
44305 if (temp8)
44306 delete arg8;
44307 }
44308 return NULL;
44309 }
44310
44311
44312 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44313 PyObject *resultobj = 0;
44314 wxControl *arg1 = (wxControl *) 0 ;
44315 int result;
44316 void *argp1 = 0 ;
44317 int res1 = 0 ;
44318 PyObject *swig_obj[1] ;
44319
44320 if (!args) SWIG_fail;
44321 swig_obj[0] = args;
44322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44323 if (!SWIG_IsOK(res1)) {
44324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
44325 }
44326 arg1 = reinterpret_cast< wxControl * >(argp1);
44327 {
44328 PyThreadState* __tstate = wxPyBeginAllowThreads();
44329 result = (int)((wxControl const *)arg1)->GetAlignment();
44330 wxPyEndAllowThreads(__tstate);
44331 if (PyErr_Occurred()) SWIG_fail;
44332 }
44333 resultobj = SWIG_From_int(static_cast< int >(result));
44334 return resultobj;
44335 fail:
44336 return NULL;
44337 }
44338
44339
44340 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44341 PyObject *resultobj = 0;
44342 wxControl *arg1 = (wxControl *) 0 ;
44343 wxString result;
44344 void *argp1 = 0 ;
44345 int res1 = 0 ;
44346 PyObject *swig_obj[1] ;
44347
44348 if (!args) SWIG_fail;
44349 swig_obj[0] = args;
44350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44351 if (!SWIG_IsOK(res1)) {
44352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
44353 }
44354 arg1 = reinterpret_cast< wxControl * >(argp1);
44355 {
44356 PyThreadState* __tstate = wxPyBeginAllowThreads();
44357 result = ((wxControl const *)arg1)->GetLabelText();
44358 wxPyEndAllowThreads(__tstate);
44359 if (PyErr_Occurred()) SWIG_fail;
44360 }
44361 {
44362 #if wxUSE_UNICODE
44363 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44364 #else
44365 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44366 #endif
44367 }
44368 return resultobj;
44369 fail:
44370 return NULL;
44371 }
44372
44373
44374 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44375 PyObject *resultobj = 0;
44376 wxControl *arg1 = (wxControl *) 0 ;
44377 wxCommandEvent *arg2 = 0 ;
44378 void *argp1 = 0 ;
44379 int res1 = 0 ;
44380 void *argp2 = 0 ;
44381 int res2 = 0 ;
44382 PyObject * obj0 = 0 ;
44383 PyObject * obj1 = 0 ;
44384 char * kwnames[] = {
44385 (char *) "self",(char *) "event", NULL
44386 };
44387
44388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
44389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44390 if (!SWIG_IsOK(res1)) {
44391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
44392 }
44393 arg1 = reinterpret_cast< wxControl * >(argp1);
44394 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
44395 if (!SWIG_IsOK(res2)) {
44396 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44397 }
44398 if (!argp2) {
44399 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44400 }
44401 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
44402 {
44403 PyThreadState* __tstate = wxPyBeginAllowThreads();
44404 (arg1)->Command(*arg2);
44405 wxPyEndAllowThreads(__tstate);
44406 if (PyErr_Occurred()) SWIG_fail;
44407 }
44408 resultobj = SWIG_Py_Void();
44409 return resultobj;
44410 fail:
44411 return NULL;
44412 }
44413
44414
44415 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44416 PyObject *resultobj = 0;
44417 wxControl *arg1 = (wxControl *) 0 ;
44418 wxString result;
44419 void *argp1 = 0 ;
44420 int res1 = 0 ;
44421 PyObject *swig_obj[1] ;
44422
44423 if (!args) SWIG_fail;
44424 swig_obj[0] = args;
44425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44426 if (!SWIG_IsOK(res1)) {
44427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
44428 }
44429 arg1 = reinterpret_cast< wxControl * >(argp1);
44430 {
44431 PyThreadState* __tstate = wxPyBeginAllowThreads();
44432 result = (arg1)->GetLabel();
44433 wxPyEndAllowThreads(__tstate);
44434 if (PyErr_Occurred()) SWIG_fail;
44435 }
44436 {
44437 #if wxUSE_UNICODE
44438 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44439 #else
44440 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44441 #endif
44442 }
44443 return resultobj;
44444 fail:
44445 return NULL;
44446 }
44447
44448
44449 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44450 PyObject *resultobj = 0;
44451 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
44452 SwigValueWrapper<wxVisualAttributes > result;
44453 int val1 ;
44454 int ecode1 = 0 ;
44455 PyObject * obj0 = 0 ;
44456 char * kwnames[] = {
44457 (char *) "variant", NULL
44458 };
44459
44460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
44461 if (obj0) {
44462 ecode1 = SWIG_AsVal_int(obj0, &val1);
44463 if (!SWIG_IsOK(ecode1)) {
44464 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
44465 }
44466 arg1 = static_cast< wxWindowVariant >(val1);
44467 }
44468 {
44469 if (!wxPyCheckForApp()) SWIG_fail;
44470 PyThreadState* __tstate = wxPyBeginAllowThreads();
44471 result = wxControl::GetClassDefaultAttributes(arg1);
44472 wxPyEndAllowThreads(__tstate);
44473 if (PyErr_Occurred()) SWIG_fail;
44474 }
44475 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
44476 return resultobj;
44477 fail:
44478 return NULL;
44479 }
44480
44481
44482 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44483 PyObject *obj;
44484 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44485 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
44486 return SWIG_Py_Void();
44487 }
44488
44489 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44490 return SWIG_Python_InitShadowInstance(args);
44491 }
44492
44493 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44494 PyObject *resultobj = 0;
44495 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44496 wxString *arg2 = 0 ;
44497 PyObject *arg3 = (PyObject *) NULL ;
44498 int result;
44499 void *argp1 = 0 ;
44500 int res1 = 0 ;
44501 bool temp2 = false ;
44502 PyObject * obj0 = 0 ;
44503 PyObject * obj1 = 0 ;
44504 PyObject * obj2 = 0 ;
44505 char * kwnames[] = {
44506 (char *) "self",(char *) "item",(char *) "clientData", NULL
44507 };
44508
44509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44511 if (!SWIG_IsOK(res1)) {
44512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44513 }
44514 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44515 {
44516 arg2 = wxString_in_helper(obj1);
44517 if (arg2 == NULL) SWIG_fail;
44518 temp2 = true;
44519 }
44520 if (obj2) {
44521 arg3 = obj2;
44522 }
44523 {
44524 PyThreadState* __tstate = wxPyBeginAllowThreads();
44525 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
44526 wxPyEndAllowThreads(__tstate);
44527 if (PyErr_Occurred()) SWIG_fail;
44528 }
44529 resultobj = SWIG_From_int(static_cast< int >(result));
44530 {
44531 if (temp2)
44532 delete arg2;
44533 }
44534 return resultobj;
44535 fail:
44536 {
44537 if (temp2)
44538 delete arg2;
44539 }
44540 return NULL;
44541 }
44542
44543
44544 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44545 PyObject *resultobj = 0;
44546 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44547 wxArrayString *arg2 = 0 ;
44548 void *argp1 = 0 ;
44549 int res1 = 0 ;
44550 bool temp2 = false ;
44551 PyObject * obj0 = 0 ;
44552 PyObject * obj1 = 0 ;
44553 char * kwnames[] = {
44554 (char *) "self",(char *) "strings", NULL
44555 };
44556
44557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
44558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44559 if (!SWIG_IsOK(res1)) {
44560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44561 }
44562 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44563 {
44564 if (! PySequence_Check(obj1)) {
44565 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
44566 SWIG_fail;
44567 }
44568 arg2 = new wxArrayString;
44569 temp2 = true;
44570 int i, len=PySequence_Length(obj1);
44571 for (i=0; i<len; i++) {
44572 PyObject* item = PySequence_GetItem(obj1, i);
44573 wxString* s = wxString_in_helper(item);
44574 if (PyErr_Occurred()) SWIG_fail;
44575 arg2->Add(*s);
44576 delete s;
44577 Py_DECREF(item);
44578 }
44579 }
44580 {
44581 PyThreadState* __tstate = wxPyBeginAllowThreads();
44582 (arg1)->Append((wxArrayString const &)*arg2);
44583 wxPyEndAllowThreads(__tstate);
44584 if (PyErr_Occurred()) SWIG_fail;
44585 }
44586 resultobj = SWIG_Py_Void();
44587 {
44588 if (temp2) delete arg2;
44589 }
44590 return resultobj;
44591 fail:
44592 {
44593 if (temp2) delete arg2;
44594 }
44595 return NULL;
44596 }
44597
44598
44599 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44600 PyObject *resultobj = 0;
44601 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44602 wxString *arg2 = 0 ;
44603 unsigned int arg3 ;
44604 PyObject *arg4 = (PyObject *) NULL ;
44605 int result;
44606 void *argp1 = 0 ;
44607 int res1 = 0 ;
44608 bool temp2 = false ;
44609 unsigned int val3 ;
44610 int ecode3 = 0 ;
44611 PyObject * obj0 = 0 ;
44612 PyObject * obj1 = 0 ;
44613 PyObject * obj2 = 0 ;
44614 PyObject * obj3 = 0 ;
44615 char * kwnames[] = {
44616 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
44617 };
44618
44619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44621 if (!SWIG_IsOK(res1)) {
44622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44623 }
44624 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44625 {
44626 arg2 = wxString_in_helper(obj1);
44627 if (arg2 == NULL) SWIG_fail;
44628 temp2 = true;
44629 }
44630 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
44631 if (!SWIG_IsOK(ecode3)) {
44632 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
44633 }
44634 arg3 = static_cast< unsigned int >(val3);
44635 if (obj3) {
44636 arg4 = obj3;
44637 }
44638 {
44639 PyThreadState* __tstate = wxPyBeginAllowThreads();
44640 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
44641 wxPyEndAllowThreads(__tstate);
44642 if (PyErr_Occurred()) SWIG_fail;
44643 }
44644 resultobj = SWIG_From_int(static_cast< int >(result));
44645 {
44646 if (temp2)
44647 delete arg2;
44648 }
44649 return resultobj;
44650 fail:
44651 {
44652 if (temp2)
44653 delete arg2;
44654 }
44655 return NULL;
44656 }
44657
44658
44659 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44660 PyObject *resultobj = 0;
44661 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44662 void *argp1 = 0 ;
44663 int res1 = 0 ;
44664 PyObject *swig_obj[1] ;
44665
44666 if (!args) SWIG_fail;
44667 swig_obj[0] = args;
44668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44669 if (!SWIG_IsOK(res1)) {
44670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44671 }
44672 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44673 {
44674 PyThreadState* __tstate = wxPyBeginAllowThreads();
44675 (arg1)->Clear();
44676 wxPyEndAllowThreads(__tstate);
44677 if (PyErr_Occurred()) SWIG_fail;
44678 }
44679 resultobj = SWIG_Py_Void();
44680 return resultobj;
44681 fail:
44682 return NULL;
44683 }
44684
44685
44686 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44687 PyObject *resultobj = 0;
44688 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44689 unsigned int arg2 ;
44690 void *argp1 = 0 ;
44691 int res1 = 0 ;
44692 unsigned int val2 ;
44693 int ecode2 = 0 ;
44694 PyObject * obj0 = 0 ;
44695 PyObject * obj1 = 0 ;
44696 char * kwnames[] = {
44697 (char *) "self",(char *) "n", NULL
44698 };
44699
44700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
44701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44702 if (!SWIG_IsOK(res1)) {
44703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44704 }
44705 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44706 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44707 if (!SWIG_IsOK(ecode2)) {
44708 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
44709 }
44710 arg2 = static_cast< unsigned int >(val2);
44711 {
44712 PyThreadState* __tstate = wxPyBeginAllowThreads();
44713 (arg1)->Delete(arg2);
44714 wxPyEndAllowThreads(__tstate);
44715 if (PyErr_Occurred()) SWIG_fail;
44716 }
44717 resultobj = SWIG_Py_Void();
44718 return resultobj;
44719 fail:
44720 return NULL;
44721 }
44722
44723
44724 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44725 PyObject *resultobj = 0;
44726 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44727 unsigned int arg2 ;
44728 PyObject *result = 0 ;
44729 void *argp1 = 0 ;
44730 int res1 = 0 ;
44731 unsigned int val2 ;
44732 int ecode2 = 0 ;
44733 PyObject * obj0 = 0 ;
44734 PyObject * obj1 = 0 ;
44735 char * kwnames[] = {
44736 (char *) "self",(char *) "n", NULL
44737 };
44738
44739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
44740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44741 if (!SWIG_IsOK(res1)) {
44742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44743 }
44744 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44745 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44746 if (!SWIG_IsOK(ecode2)) {
44747 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44748 }
44749 arg2 = static_cast< unsigned int >(val2);
44750 {
44751 PyThreadState* __tstate = wxPyBeginAllowThreads();
44752 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
44753 wxPyEndAllowThreads(__tstate);
44754 if (PyErr_Occurred()) SWIG_fail;
44755 }
44756 resultobj = result;
44757 return resultobj;
44758 fail:
44759 return NULL;
44760 }
44761
44762
44763 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44764 PyObject *resultobj = 0;
44765 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44766 unsigned int arg2 ;
44767 PyObject *arg3 = (PyObject *) 0 ;
44768 void *argp1 = 0 ;
44769 int res1 = 0 ;
44770 unsigned int val2 ;
44771 int ecode2 = 0 ;
44772 PyObject * obj0 = 0 ;
44773 PyObject * obj1 = 0 ;
44774 PyObject * obj2 = 0 ;
44775 char * kwnames[] = {
44776 (char *) "self",(char *) "n",(char *) "clientData", NULL
44777 };
44778
44779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44781 if (!SWIG_IsOK(res1)) {
44782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44783 }
44784 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44785 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44786 if (!SWIG_IsOK(ecode2)) {
44787 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44788 }
44789 arg2 = static_cast< unsigned int >(val2);
44790 arg3 = obj2;
44791 {
44792 PyThreadState* __tstate = wxPyBeginAllowThreads();
44793 wxItemContainer_SetClientData(arg1,arg2,arg3);
44794 wxPyEndAllowThreads(__tstate);
44795 if (PyErr_Occurred()) SWIG_fail;
44796 }
44797 resultobj = SWIG_Py_Void();
44798 return resultobj;
44799 fail:
44800 return NULL;
44801 }
44802
44803
44804 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44805 PyObject *resultobj = 0;
44806 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44807 unsigned int result;
44808 void *argp1 = 0 ;
44809 int res1 = 0 ;
44810 PyObject *swig_obj[1] ;
44811
44812 if (!args) SWIG_fail;
44813 swig_obj[0] = args;
44814 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44815 if (!SWIG_IsOK(res1)) {
44816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44817 }
44818 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44819 {
44820 PyThreadState* __tstate = wxPyBeginAllowThreads();
44821 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
44822 wxPyEndAllowThreads(__tstate);
44823 if (PyErr_Occurred()) SWIG_fail;
44824 }
44825 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
44826 return resultobj;
44827 fail:
44828 return NULL;
44829 }
44830
44831
44832 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44833 PyObject *resultobj = 0;
44834 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44835 bool result;
44836 void *argp1 = 0 ;
44837 int res1 = 0 ;
44838 PyObject *swig_obj[1] ;
44839
44840 if (!args) SWIG_fail;
44841 swig_obj[0] = args;
44842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44843 if (!SWIG_IsOK(res1)) {
44844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44845 }
44846 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44847 {
44848 PyThreadState* __tstate = wxPyBeginAllowThreads();
44849 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
44850 wxPyEndAllowThreads(__tstate);
44851 if (PyErr_Occurred()) SWIG_fail;
44852 }
44853 {
44854 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44855 }
44856 return resultobj;
44857 fail:
44858 return NULL;
44859 }
44860
44861
44862 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44863 PyObject *resultobj = 0;
44864 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44865 unsigned int arg2 ;
44866 wxString result;
44867 void *argp1 = 0 ;
44868 int res1 = 0 ;
44869 unsigned int val2 ;
44870 int ecode2 = 0 ;
44871 PyObject * obj0 = 0 ;
44872 PyObject * obj1 = 0 ;
44873 char * kwnames[] = {
44874 (char *) "self",(char *) "n", NULL
44875 };
44876
44877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
44878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44879 if (!SWIG_IsOK(res1)) {
44880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44881 }
44882 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44883 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44884 if (!SWIG_IsOK(ecode2)) {
44885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
44886 }
44887 arg2 = static_cast< unsigned int >(val2);
44888 {
44889 PyThreadState* __tstate = wxPyBeginAllowThreads();
44890 result = ((wxItemContainer const *)arg1)->GetString(arg2);
44891 wxPyEndAllowThreads(__tstate);
44892 if (PyErr_Occurred()) SWIG_fail;
44893 }
44894 {
44895 #if wxUSE_UNICODE
44896 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44897 #else
44898 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44899 #endif
44900 }
44901 return resultobj;
44902 fail:
44903 return NULL;
44904 }
44905
44906
44907 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44908 PyObject *resultobj = 0;
44909 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44910 wxArrayString result;
44911 void *argp1 = 0 ;
44912 int res1 = 0 ;
44913 PyObject *swig_obj[1] ;
44914
44915 if (!args) SWIG_fail;
44916 swig_obj[0] = args;
44917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44918 if (!SWIG_IsOK(res1)) {
44919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44920 }
44921 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44922 {
44923 PyThreadState* __tstate = wxPyBeginAllowThreads();
44924 result = ((wxItemContainer const *)arg1)->GetStrings();
44925 wxPyEndAllowThreads(__tstate);
44926 if (PyErr_Occurred()) SWIG_fail;
44927 }
44928 {
44929 resultobj = wxArrayString2PyList_helper(result);
44930 }
44931 return resultobj;
44932 fail:
44933 return NULL;
44934 }
44935
44936
44937 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44938 PyObject *resultobj = 0;
44939 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44940 unsigned int arg2 ;
44941 wxString *arg3 = 0 ;
44942 void *argp1 = 0 ;
44943 int res1 = 0 ;
44944 unsigned int val2 ;
44945 int ecode2 = 0 ;
44946 bool temp3 = false ;
44947 PyObject * obj0 = 0 ;
44948 PyObject * obj1 = 0 ;
44949 PyObject * obj2 = 0 ;
44950 char * kwnames[] = {
44951 (char *) "self",(char *) "n",(char *) "s", NULL
44952 };
44953
44954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44956 if (!SWIG_IsOK(res1)) {
44957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44958 }
44959 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44960 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44961 if (!SWIG_IsOK(ecode2)) {
44962 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
44963 }
44964 arg2 = static_cast< unsigned int >(val2);
44965 {
44966 arg3 = wxString_in_helper(obj2);
44967 if (arg3 == NULL) SWIG_fail;
44968 temp3 = true;
44969 }
44970 {
44971 PyThreadState* __tstate = wxPyBeginAllowThreads();
44972 (arg1)->SetString(arg2,(wxString const &)*arg3);
44973 wxPyEndAllowThreads(__tstate);
44974 if (PyErr_Occurred()) SWIG_fail;
44975 }
44976 resultobj = SWIG_Py_Void();
44977 {
44978 if (temp3)
44979 delete arg3;
44980 }
44981 return resultobj;
44982 fail:
44983 {
44984 if (temp3)
44985 delete arg3;
44986 }
44987 return NULL;
44988 }
44989
44990
44991 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44992 PyObject *resultobj = 0;
44993 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44994 wxString *arg2 = 0 ;
44995 int result;
44996 void *argp1 = 0 ;
44997 int res1 = 0 ;
44998 bool temp2 = false ;
44999 PyObject * obj0 = 0 ;
45000 PyObject * obj1 = 0 ;
45001 char * kwnames[] = {
45002 (char *) "self",(char *) "s", NULL
45003 };
45004
45005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
45006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45007 if (!SWIG_IsOK(res1)) {
45008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45009 }
45010 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45011 {
45012 arg2 = wxString_in_helper(obj1);
45013 if (arg2 == NULL) SWIG_fail;
45014 temp2 = true;
45015 }
45016 {
45017 PyThreadState* __tstate = wxPyBeginAllowThreads();
45018 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
45019 wxPyEndAllowThreads(__tstate);
45020 if (PyErr_Occurred()) SWIG_fail;
45021 }
45022 resultobj = SWIG_From_int(static_cast< int >(result));
45023 {
45024 if (temp2)
45025 delete arg2;
45026 }
45027 return resultobj;
45028 fail:
45029 {
45030 if (temp2)
45031 delete arg2;
45032 }
45033 return NULL;
45034 }
45035
45036
45037 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45038 PyObject *resultobj = 0;
45039 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45040 int arg2 ;
45041 void *argp1 = 0 ;
45042 int res1 = 0 ;
45043 int val2 ;
45044 int ecode2 = 0 ;
45045 PyObject * obj0 = 0 ;
45046 PyObject * obj1 = 0 ;
45047 char * kwnames[] = {
45048 (char *) "self",(char *) "n", NULL
45049 };
45050
45051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
45052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45053 if (!SWIG_IsOK(res1)) {
45054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45055 }
45056 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45057 ecode2 = SWIG_AsVal_int(obj1, &val2);
45058 if (!SWIG_IsOK(ecode2)) {
45059 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
45060 }
45061 arg2 = static_cast< int >(val2);
45062 {
45063 PyThreadState* __tstate = wxPyBeginAllowThreads();
45064 (arg1)->SetSelection(arg2);
45065 wxPyEndAllowThreads(__tstate);
45066 if (PyErr_Occurred()) SWIG_fail;
45067 }
45068 resultobj = SWIG_Py_Void();
45069 return resultobj;
45070 fail:
45071 return NULL;
45072 }
45073
45074
45075 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45076 PyObject *resultobj = 0;
45077 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45078 int result;
45079 void *argp1 = 0 ;
45080 int res1 = 0 ;
45081 PyObject *swig_obj[1] ;
45082
45083 if (!args) SWIG_fail;
45084 swig_obj[0] = args;
45085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45086 if (!SWIG_IsOK(res1)) {
45087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45088 }
45089 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45090 {
45091 PyThreadState* __tstate = wxPyBeginAllowThreads();
45092 result = (int)((wxItemContainer const *)arg1)->GetSelection();
45093 wxPyEndAllowThreads(__tstate);
45094 if (PyErr_Occurred()) SWIG_fail;
45095 }
45096 resultobj = SWIG_From_int(static_cast< int >(result));
45097 return resultobj;
45098 fail:
45099 return NULL;
45100 }
45101
45102
45103 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45104 PyObject *resultobj = 0;
45105 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45106 wxString *arg2 = 0 ;
45107 bool result;
45108 void *argp1 = 0 ;
45109 int res1 = 0 ;
45110 bool temp2 = false ;
45111 PyObject * obj0 = 0 ;
45112 PyObject * obj1 = 0 ;
45113 char * kwnames[] = {
45114 (char *) "self",(char *) "s", NULL
45115 };
45116
45117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
45118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45119 if (!SWIG_IsOK(res1)) {
45120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45121 }
45122 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45123 {
45124 arg2 = wxString_in_helper(obj1);
45125 if (arg2 == NULL) SWIG_fail;
45126 temp2 = true;
45127 }
45128 {
45129 PyThreadState* __tstate = wxPyBeginAllowThreads();
45130 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
45131 wxPyEndAllowThreads(__tstate);
45132 if (PyErr_Occurred()) SWIG_fail;
45133 }
45134 {
45135 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45136 }
45137 {
45138 if (temp2)
45139 delete arg2;
45140 }
45141 return resultobj;
45142 fail:
45143 {
45144 if (temp2)
45145 delete arg2;
45146 }
45147 return NULL;
45148 }
45149
45150
45151 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45152 PyObject *resultobj = 0;
45153 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45154 wxString result;
45155 void *argp1 = 0 ;
45156 int res1 = 0 ;
45157 PyObject *swig_obj[1] ;
45158
45159 if (!args) SWIG_fail;
45160 swig_obj[0] = args;
45161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45162 if (!SWIG_IsOK(res1)) {
45163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45164 }
45165 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45166 {
45167 PyThreadState* __tstate = wxPyBeginAllowThreads();
45168 result = ((wxItemContainer const *)arg1)->GetStringSelection();
45169 wxPyEndAllowThreads(__tstate);
45170 if (PyErr_Occurred()) SWIG_fail;
45171 }
45172 {
45173 #if wxUSE_UNICODE
45174 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45175 #else
45176 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45177 #endif
45178 }
45179 return resultobj;
45180 fail:
45181 return NULL;
45182 }
45183
45184
45185 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45186 PyObject *resultobj = 0;
45187 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45188 int arg2 ;
45189 void *argp1 = 0 ;
45190 int res1 = 0 ;
45191 int val2 ;
45192 int ecode2 = 0 ;
45193 PyObject * obj0 = 0 ;
45194 PyObject * obj1 = 0 ;
45195 char * kwnames[] = {
45196 (char *) "self",(char *) "n", NULL
45197 };
45198
45199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
45200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45201 if (!SWIG_IsOK(res1)) {
45202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45203 }
45204 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45205 ecode2 = SWIG_AsVal_int(obj1, &val2);
45206 if (!SWIG_IsOK(ecode2)) {
45207 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
45208 }
45209 arg2 = static_cast< int >(val2);
45210 {
45211 PyThreadState* __tstate = wxPyBeginAllowThreads();
45212 (arg1)->Select(arg2);
45213 wxPyEndAllowThreads(__tstate);
45214 if (PyErr_Occurred()) SWIG_fail;
45215 }
45216 resultobj = SWIG_Py_Void();
45217 return resultobj;
45218 fail:
45219 return NULL;
45220 }
45221
45222
45223 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45224 PyObject *obj;
45225 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45226 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
45227 return SWIG_Py_Void();
45228 }
45229
45230 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45231 PyObject *obj;
45232 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45233 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
45234 return SWIG_Py_Void();
45235 }
45236
45237 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45238 PyObject *resultobj = 0;
45239 wxSizerItem *result = 0 ;
45240
45241 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
45242 {
45243 PyThreadState* __tstate = wxPyBeginAllowThreads();
45244 result = (wxSizerItem *)new wxSizerItem();
45245 wxPyEndAllowThreads(__tstate);
45246 if (PyErr_Occurred()) SWIG_fail;
45247 }
45248 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
45249 return resultobj;
45250 fail:
45251 return NULL;
45252 }
45253
45254
45255 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45256 PyObject *resultobj = 0;
45257 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45258 void *argp1 = 0 ;
45259 int res1 = 0 ;
45260 PyObject *swig_obj[1] ;
45261
45262 if (!args) SWIG_fail;
45263 swig_obj[0] = args;
45264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
45265 if (!SWIG_IsOK(res1)) {
45266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45267 }
45268 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45269 {
45270 PyThreadState* __tstate = wxPyBeginAllowThreads();
45271 delete arg1;
45272
45273 wxPyEndAllowThreads(__tstate);
45274 if (PyErr_Occurred()) SWIG_fail;
45275 }
45276 resultobj = SWIG_Py_Void();
45277 return resultobj;
45278 fail:
45279 return NULL;
45280 }
45281
45282
45283 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45284 PyObject *resultobj = 0;
45285 wxWindow *arg1 = (wxWindow *) 0 ;
45286 int arg2 ;
45287 int arg3 ;
45288 int arg4 ;
45289 PyObject *arg5 = (PyObject *) NULL ;
45290 wxSizerItem *result = 0 ;
45291 void *argp1 = 0 ;
45292 int res1 = 0 ;
45293 int val2 ;
45294 int ecode2 = 0 ;
45295 int val3 ;
45296 int ecode3 = 0 ;
45297 int val4 ;
45298 int ecode4 = 0 ;
45299 PyObject * obj0 = 0 ;
45300 PyObject * obj1 = 0 ;
45301 PyObject * obj2 = 0 ;
45302 PyObject * obj3 = 0 ;
45303 PyObject * obj4 = 0 ;
45304 char * kwnames[] = {
45305 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45306 };
45307
45308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
45310 if (!SWIG_IsOK(res1)) {
45311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
45312 }
45313 arg1 = reinterpret_cast< wxWindow * >(argp1);
45314 ecode2 = SWIG_AsVal_int(obj1, &val2);
45315 if (!SWIG_IsOK(ecode2)) {
45316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
45317 }
45318 arg2 = static_cast< int >(val2);
45319 ecode3 = SWIG_AsVal_int(obj2, &val3);
45320 if (!SWIG_IsOK(ecode3)) {
45321 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
45322 }
45323 arg3 = static_cast< int >(val3);
45324 ecode4 = SWIG_AsVal_int(obj3, &val4);
45325 if (!SWIG_IsOK(ecode4)) {
45326 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
45327 }
45328 arg4 = static_cast< int >(val4);
45329 if (obj4) {
45330 arg5 = obj4;
45331 }
45332 {
45333 PyThreadState* __tstate = wxPyBeginAllowThreads();
45334 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45335 wxPyEndAllowThreads(__tstate);
45336 if (PyErr_Occurred()) SWIG_fail;
45337 }
45338 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45339 return resultobj;
45340 fail:
45341 return NULL;
45342 }
45343
45344
45345 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45346 PyObject *resultobj = 0;
45347 int arg1 ;
45348 int arg2 ;
45349 int arg3 ;
45350 int arg4 ;
45351 int arg5 ;
45352 PyObject *arg6 = (PyObject *) NULL ;
45353 wxSizerItem *result = 0 ;
45354 int val1 ;
45355 int ecode1 = 0 ;
45356 int val2 ;
45357 int ecode2 = 0 ;
45358 int val3 ;
45359 int ecode3 = 0 ;
45360 int val4 ;
45361 int ecode4 = 0 ;
45362 int val5 ;
45363 int ecode5 = 0 ;
45364 PyObject * obj0 = 0 ;
45365 PyObject * obj1 = 0 ;
45366 PyObject * obj2 = 0 ;
45367 PyObject * obj3 = 0 ;
45368 PyObject * obj4 = 0 ;
45369 PyObject * obj5 = 0 ;
45370 char * kwnames[] = {
45371 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45372 };
45373
45374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45375 ecode1 = SWIG_AsVal_int(obj0, &val1);
45376 if (!SWIG_IsOK(ecode1)) {
45377 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
45378 }
45379 arg1 = static_cast< int >(val1);
45380 ecode2 = SWIG_AsVal_int(obj1, &val2);
45381 if (!SWIG_IsOK(ecode2)) {
45382 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
45383 }
45384 arg2 = static_cast< int >(val2);
45385 ecode3 = SWIG_AsVal_int(obj2, &val3);
45386 if (!SWIG_IsOK(ecode3)) {
45387 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
45388 }
45389 arg3 = static_cast< int >(val3);
45390 ecode4 = SWIG_AsVal_int(obj3, &val4);
45391 if (!SWIG_IsOK(ecode4)) {
45392 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
45393 }
45394 arg4 = static_cast< int >(val4);
45395 ecode5 = SWIG_AsVal_int(obj4, &val5);
45396 if (!SWIG_IsOK(ecode5)) {
45397 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
45398 }
45399 arg5 = static_cast< int >(val5);
45400 if (obj5) {
45401 arg6 = obj5;
45402 }
45403 {
45404 PyThreadState* __tstate = wxPyBeginAllowThreads();
45405 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
45406 wxPyEndAllowThreads(__tstate);
45407 if (PyErr_Occurred()) SWIG_fail;
45408 }
45409 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45410 return resultobj;
45411 fail:
45412 return NULL;
45413 }
45414
45415
45416 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45417 PyObject *resultobj = 0;
45418 wxSizer *arg1 = (wxSizer *) 0 ;
45419 int arg2 ;
45420 int arg3 ;
45421 int arg4 ;
45422 PyObject *arg5 = (PyObject *) NULL ;
45423 wxSizerItem *result = 0 ;
45424 int res1 = 0 ;
45425 int val2 ;
45426 int ecode2 = 0 ;
45427 int val3 ;
45428 int ecode3 = 0 ;
45429 int val4 ;
45430 int ecode4 = 0 ;
45431 PyObject * obj0 = 0 ;
45432 PyObject * obj1 = 0 ;
45433 PyObject * obj2 = 0 ;
45434 PyObject * obj3 = 0 ;
45435 PyObject * obj4 = 0 ;
45436 char * kwnames[] = {
45437 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45438 };
45439
45440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45441 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45442 if (!SWIG_IsOK(res1)) {
45443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
45444 }
45445 ecode2 = SWIG_AsVal_int(obj1, &val2);
45446 if (!SWIG_IsOK(ecode2)) {
45447 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
45448 }
45449 arg2 = static_cast< int >(val2);
45450 ecode3 = SWIG_AsVal_int(obj2, &val3);
45451 if (!SWIG_IsOK(ecode3)) {
45452 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
45453 }
45454 arg3 = static_cast< int >(val3);
45455 ecode4 = SWIG_AsVal_int(obj3, &val4);
45456 if (!SWIG_IsOK(ecode4)) {
45457 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
45458 }
45459 arg4 = static_cast< int >(val4);
45460 if (obj4) {
45461 arg5 = obj4;
45462 }
45463 {
45464 PyThreadState* __tstate = wxPyBeginAllowThreads();
45465 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45466 wxPyEndAllowThreads(__tstate);
45467 if (PyErr_Occurred()) SWIG_fail;
45468 }
45469 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45470 return resultobj;
45471 fail:
45472 return NULL;
45473 }
45474
45475
45476 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45477 PyObject *resultobj = 0;
45478 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45479 void *argp1 = 0 ;
45480 int res1 = 0 ;
45481 PyObject *swig_obj[1] ;
45482
45483 if (!args) SWIG_fail;
45484 swig_obj[0] = args;
45485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45486 if (!SWIG_IsOK(res1)) {
45487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45488 }
45489 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45490 {
45491 PyThreadState* __tstate = wxPyBeginAllowThreads();
45492 (arg1)->DeleteWindows();
45493 wxPyEndAllowThreads(__tstate);
45494 if (PyErr_Occurred()) SWIG_fail;
45495 }
45496 resultobj = SWIG_Py_Void();
45497 return resultobj;
45498 fail:
45499 return NULL;
45500 }
45501
45502
45503 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45504 PyObject *resultobj = 0;
45505 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45506 void *argp1 = 0 ;
45507 int res1 = 0 ;
45508 PyObject *swig_obj[1] ;
45509
45510 if (!args) SWIG_fail;
45511 swig_obj[0] = args;
45512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45513 if (!SWIG_IsOK(res1)) {
45514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45515 }
45516 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45517 {
45518 PyThreadState* __tstate = wxPyBeginAllowThreads();
45519 (arg1)->DetachSizer();
45520 wxPyEndAllowThreads(__tstate);
45521 if (PyErr_Occurred()) SWIG_fail;
45522 }
45523 resultobj = SWIG_Py_Void();
45524 return resultobj;
45525 fail:
45526 return NULL;
45527 }
45528
45529
45530 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45531 PyObject *resultobj = 0;
45532 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45533 wxSize result;
45534 void *argp1 = 0 ;
45535 int res1 = 0 ;
45536 PyObject *swig_obj[1] ;
45537
45538 if (!args) SWIG_fail;
45539 swig_obj[0] = args;
45540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45541 if (!SWIG_IsOK(res1)) {
45542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45543 }
45544 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45545 {
45546 PyThreadState* __tstate = wxPyBeginAllowThreads();
45547 result = (arg1)->GetSize();
45548 wxPyEndAllowThreads(__tstate);
45549 if (PyErr_Occurred()) SWIG_fail;
45550 }
45551 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45552 return resultobj;
45553 fail:
45554 return NULL;
45555 }
45556
45557
45558 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45559 PyObject *resultobj = 0;
45560 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45561 wxSize result;
45562 void *argp1 = 0 ;
45563 int res1 = 0 ;
45564 PyObject *swig_obj[1] ;
45565
45566 if (!args) SWIG_fail;
45567 swig_obj[0] = args;
45568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45569 if (!SWIG_IsOK(res1)) {
45570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45571 }
45572 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45573 {
45574 PyThreadState* __tstate = wxPyBeginAllowThreads();
45575 result = (arg1)->CalcMin();
45576 wxPyEndAllowThreads(__tstate);
45577 if (PyErr_Occurred()) SWIG_fail;
45578 }
45579 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45580 return resultobj;
45581 fail:
45582 return NULL;
45583 }
45584
45585
45586 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45587 PyObject *resultobj = 0;
45588 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45589 wxPoint *arg2 = 0 ;
45590 wxSize *arg3 = 0 ;
45591 void *argp1 = 0 ;
45592 int res1 = 0 ;
45593 wxPoint temp2 ;
45594 wxSize temp3 ;
45595 PyObject * obj0 = 0 ;
45596 PyObject * obj1 = 0 ;
45597 PyObject * obj2 = 0 ;
45598 char * kwnames[] = {
45599 (char *) "self",(char *) "pos",(char *) "size", NULL
45600 };
45601
45602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45604 if (!SWIG_IsOK(res1)) {
45605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45606 }
45607 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45608 {
45609 arg2 = &temp2;
45610 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
45611 }
45612 {
45613 arg3 = &temp3;
45614 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
45615 }
45616 {
45617 PyThreadState* __tstate = wxPyBeginAllowThreads();
45618 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
45619 wxPyEndAllowThreads(__tstate);
45620 if (PyErr_Occurred()) SWIG_fail;
45621 }
45622 resultobj = SWIG_Py_Void();
45623 return resultobj;
45624 fail:
45625 return NULL;
45626 }
45627
45628
45629 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45630 PyObject *resultobj = 0;
45631 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45632 wxSize result;
45633 void *argp1 = 0 ;
45634 int res1 = 0 ;
45635 PyObject *swig_obj[1] ;
45636
45637 if (!args) SWIG_fail;
45638 swig_obj[0] = args;
45639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45640 if (!SWIG_IsOK(res1)) {
45641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45642 }
45643 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45644 {
45645 PyThreadState* __tstate = wxPyBeginAllowThreads();
45646 result = (arg1)->GetMinSize();
45647 wxPyEndAllowThreads(__tstate);
45648 if (PyErr_Occurred()) SWIG_fail;
45649 }
45650 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45651 return resultobj;
45652 fail:
45653 return NULL;
45654 }
45655
45656
45657 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45658 PyObject *resultobj = 0;
45659 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45660 wxSize result;
45661 void *argp1 = 0 ;
45662 int res1 = 0 ;
45663 PyObject *swig_obj[1] ;
45664
45665 if (!args) SWIG_fail;
45666 swig_obj[0] = args;
45667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45668 if (!SWIG_IsOK(res1)) {
45669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
45670 }
45671 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45672 {
45673 PyThreadState* __tstate = wxPyBeginAllowThreads();
45674 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
45675 wxPyEndAllowThreads(__tstate);
45676 if (PyErr_Occurred()) SWIG_fail;
45677 }
45678 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45679 return resultobj;
45680 fail:
45681 return NULL;
45682 }
45683
45684
45685 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45686 PyObject *resultobj = 0;
45687 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45688 int arg2 ;
45689 int arg3 ;
45690 void *argp1 = 0 ;
45691 int res1 = 0 ;
45692 int val2 ;
45693 int ecode2 = 0 ;
45694 int val3 ;
45695 int ecode3 = 0 ;
45696 PyObject * obj0 = 0 ;
45697 PyObject * obj1 = 0 ;
45698 PyObject * obj2 = 0 ;
45699 char * kwnames[] = {
45700 (char *) "self",(char *) "x",(char *) "y", NULL
45701 };
45702
45703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45705 if (!SWIG_IsOK(res1)) {
45706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45707 }
45708 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45709 ecode2 = SWIG_AsVal_int(obj1, &val2);
45710 if (!SWIG_IsOK(ecode2)) {
45711 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
45712 }
45713 arg2 = static_cast< int >(val2);
45714 ecode3 = SWIG_AsVal_int(obj2, &val3);
45715 if (!SWIG_IsOK(ecode3)) {
45716 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
45717 }
45718 arg3 = static_cast< int >(val3);
45719 {
45720 PyThreadState* __tstate = wxPyBeginAllowThreads();
45721 (arg1)->SetInitSize(arg2,arg3);
45722 wxPyEndAllowThreads(__tstate);
45723 if (PyErr_Occurred()) SWIG_fail;
45724 }
45725 resultobj = SWIG_Py_Void();
45726 return resultobj;
45727 fail:
45728 return NULL;
45729 }
45730
45731
45732 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45733 PyObject *resultobj = 0;
45734 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45735 int arg2 ;
45736 int arg3 ;
45737 void *argp1 = 0 ;
45738 int res1 = 0 ;
45739 int val2 ;
45740 int ecode2 = 0 ;
45741 int val3 ;
45742 int ecode3 = 0 ;
45743 PyObject * obj0 = 0 ;
45744 PyObject * obj1 = 0 ;
45745 PyObject * obj2 = 0 ;
45746 char * kwnames[] = {
45747 (char *) "self",(char *) "width",(char *) "height", NULL
45748 };
45749
45750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45752 if (!SWIG_IsOK(res1)) {
45753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45754 }
45755 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45756 ecode2 = SWIG_AsVal_int(obj1, &val2);
45757 if (!SWIG_IsOK(ecode2)) {
45758 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
45759 }
45760 arg2 = static_cast< int >(val2);
45761 ecode3 = SWIG_AsVal_int(obj2, &val3);
45762 if (!SWIG_IsOK(ecode3)) {
45763 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
45764 }
45765 arg3 = static_cast< int >(val3);
45766 {
45767 PyThreadState* __tstate = wxPyBeginAllowThreads();
45768 (arg1)->SetRatio(arg2,arg3);
45769 wxPyEndAllowThreads(__tstate);
45770 if (PyErr_Occurred()) SWIG_fail;
45771 }
45772 resultobj = SWIG_Py_Void();
45773 return resultobj;
45774 fail:
45775 return NULL;
45776 }
45777
45778
45779 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45780 PyObject *resultobj = 0;
45781 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45782 wxSize *arg2 = 0 ;
45783 void *argp1 = 0 ;
45784 int res1 = 0 ;
45785 wxSize temp2 ;
45786 PyObject * obj0 = 0 ;
45787 PyObject * obj1 = 0 ;
45788 char * kwnames[] = {
45789 (char *) "self",(char *) "size", NULL
45790 };
45791
45792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
45793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45794 if (!SWIG_IsOK(res1)) {
45795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45796 }
45797 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45798 {
45799 arg2 = &temp2;
45800 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45801 }
45802 {
45803 PyThreadState* __tstate = wxPyBeginAllowThreads();
45804 (arg1)->SetRatio((wxSize const &)*arg2);
45805 wxPyEndAllowThreads(__tstate);
45806 if (PyErr_Occurred()) SWIG_fail;
45807 }
45808 resultobj = SWIG_Py_Void();
45809 return resultobj;
45810 fail:
45811 return NULL;
45812 }
45813
45814
45815 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45816 PyObject *resultobj = 0;
45817 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45818 float arg2 ;
45819 void *argp1 = 0 ;
45820 int res1 = 0 ;
45821 float val2 ;
45822 int ecode2 = 0 ;
45823 PyObject * obj0 = 0 ;
45824 PyObject * obj1 = 0 ;
45825 char * kwnames[] = {
45826 (char *) "self",(char *) "ratio", NULL
45827 };
45828
45829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
45830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45831 if (!SWIG_IsOK(res1)) {
45832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45833 }
45834 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45835 ecode2 = SWIG_AsVal_float(obj1, &val2);
45836 if (!SWIG_IsOK(ecode2)) {
45837 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
45838 }
45839 arg2 = static_cast< float >(val2);
45840 {
45841 PyThreadState* __tstate = wxPyBeginAllowThreads();
45842 (arg1)->SetRatio(arg2);
45843 wxPyEndAllowThreads(__tstate);
45844 if (PyErr_Occurred()) SWIG_fail;
45845 }
45846 resultobj = SWIG_Py_Void();
45847 return resultobj;
45848 fail:
45849 return NULL;
45850 }
45851
45852
45853 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45854 PyObject *resultobj = 0;
45855 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45856 float result;
45857 void *argp1 = 0 ;
45858 int res1 = 0 ;
45859 PyObject *swig_obj[1] ;
45860
45861 if (!args) SWIG_fail;
45862 swig_obj[0] = args;
45863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45864 if (!SWIG_IsOK(res1)) {
45865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45866 }
45867 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45868 {
45869 PyThreadState* __tstate = wxPyBeginAllowThreads();
45870 result = (float)(arg1)->GetRatio();
45871 wxPyEndAllowThreads(__tstate);
45872 if (PyErr_Occurred()) SWIG_fail;
45873 }
45874 resultobj = SWIG_From_float(static_cast< float >(result));
45875 return resultobj;
45876 fail:
45877 return NULL;
45878 }
45879
45880
45881 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45882 PyObject *resultobj = 0;
45883 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45884 wxRect result;
45885 void *argp1 = 0 ;
45886 int res1 = 0 ;
45887 PyObject *swig_obj[1] ;
45888
45889 if (!args) SWIG_fail;
45890 swig_obj[0] = args;
45891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45892 if (!SWIG_IsOK(res1)) {
45893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45894 }
45895 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45896 {
45897 PyThreadState* __tstate = wxPyBeginAllowThreads();
45898 result = (arg1)->GetRect();
45899 wxPyEndAllowThreads(__tstate);
45900 if (PyErr_Occurred()) SWIG_fail;
45901 }
45902 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
45903 return resultobj;
45904 fail:
45905 return NULL;
45906 }
45907
45908
45909 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45910 PyObject *resultobj = 0;
45911 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45912 bool result;
45913 void *argp1 = 0 ;
45914 int res1 = 0 ;
45915 PyObject *swig_obj[1] ;
45916
45917 if (!args) SWIG_fail;
45918 swig_obj[0] = args;
45919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45920 if (!SWIG_IsOK(res1)) {
45921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45922 }
45923 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45924 {
45925 PyThreadState* __tstate = wxPyBeginAllowThreads();
45926 result = (bool)(arg1)->IsWindow();
45927 wxPyEndAllowThreads(__tstate);
45928 if (PyErr_Occurred()) SWIG_fail;
45929 }
45930 {
45931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45932 }
45933 return resultobj;
45934 fail:
45935 return NULL;
45936 }
45937
45938
45939 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45940 PyObject *resultobj = 0;
45941 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45942 bool result;
45943 void *argp1 = 0 ;
45944 int res1 = 0 ;
45945 PyObject *swig_obj[1] ;
45946
45947 if (!args) SWIG_fail;
45948 swig_obj[0] = args;
45949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45950 if (!SWIG_IsOK(res1)) {
45951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45952 }
45953 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45954 {
45955 PyThreadState* __tstate = wxPyBeginAllowThreads();
45956 result = (bool)(arg1)->IsSizer();
45957 wxPyEndAllowThreads(__tstate);
45958 if (PyErr_Occurred()) SWIG_fail;
45959 }
45960 {
45961 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45962 }
45963 return resultobj;
45964 fail:
45965 return NULL;
45966 }
45967
45968
45969 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45970 PyObject *resultobj = 0;
45971 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45972 bool result;
45973 void *argp1 = 0 ;
45974 int res1 = 0 ;
45975 PyObject *swig_obj[1] ;
45976
45977 if (!args) SWIG_fail;
45978 swig_obj[0] = args;
45979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45980 if (!SWIG_IsOK(res1)) {
45981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45982 }
45983 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45984 {
45985 PyThreadState* __tstate = wxPyBeginAllowThreads();
45986 result = (bool)(arg1)->IsSpacer();
45987 wxPyEndAllowThreads(__tstate);
45988 if (PyErr_Occurred()) SWIG_fail;
45989 }
45990 {
45991 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45992 }
45993 return resultobj;
45994 fail:
45995 return NULL;
45996 }
45997
45998
45999 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46000 PyObject *resultobj = 0;
46001 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46002 int arg2 ;
46003 void *argp1 = 0 ;
46004 int res1 = 0 ;
46005 int val2 ;
46006 int ecode2 = 0 ;
46007 PyObject * obj0 = 0 ;
46008 PyObject * obj1 = 0 ;
46009 char * kwnames[] = {
46010 (char *) "self",(char *) "proportion", NULL
46011 };
46012
46013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
46014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46015 if (!SWIG_IsOK(res1)) {
46016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46017 }
46018 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46019 ecode2 = SWIG_AsVal_int(obj1, &val2);
46020 if (!SWIG_IsOK(ecode2)) {
46021 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
46022 }
46023 arg2 = static_cast< int >(val2);
46024 {
46025 PyThreadState* __tstate = wxPyBeginAllowThreads();
46026 (arg1)->SetProportion(arg2);
46027 wxPyEndAllowThreads(__tstate);
46028 if (PyErr_Occurred()) SWIG_fail;
46029 }
46030 resultobj = SWIG_Py_Void();
46031 return resultobj;
46032 fail:
46033 return NULL;
46034 }
46035
46036
46037 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46038 PyObject *resultobj = 0;
46039 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46040 int result;
46041 void *argp1 = 0 ;
46042 int res1 = 0 ;
46043 PyObject *swig_obj[1] ;
46044
46045 if (!args) SWIG_fail;
46046 swig_obj[0] = args;
46047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46048 if (!SWIG_IsOK(res1)) {
46049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46050 }
46051 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46052 {
46053 PyThreadState* __tstate = wxPyBeginAllowThreads();
46054 result = (int)(arg1)->GetProportion();
46055 wxPyEndAllowThreads(__tstate);
46056 if (PyErr_Occurred()) SWIG_fail;
46057 }
46058 resultobj = SWIG_From_int(static_cast< int >(result));
46059 return resultobj;
46060 fail:
46061 return NULL;
46062 }
46063
46064
46065 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46066 PyObject *resultobj = 0;
46067 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46068 int arg2 ;
46069 void *argp1 = 0 ;
46070 int res1 = 0 ;
46071 int val2 ;
46072 int ecode2 = 0 ;
46073 PyObject * obj0 = 0 ;
46074 PyObject * obj1 = 0 ;
46075 char * kwnames[] = {
46076 (char *) "self",(char *) "flag", NULL
46077 };
46078
46079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
46080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46081 if (!SWIG_IsOK(res1)) {
46082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46083 }
46084 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46085 ecode2 = SWIG_AsVal_int(obj1, &val2);
46086 if (!SWIG_IsOK(ecode2)) {
46087 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
46088 }
46089 arg2 = static_cast< int >(val2);
46090 {
46091 PyThreadState* __tstate = wxPyBeginAllowThreads();
46092 (arg1)->SetFlag(arg2);
46093 wxPyEndAllowThreads(__tstate);
46094 if (PyErr_Occurred()) SWIG_fail;
46095 }
46096 resultobj = SWIG_Py_Void();
46097 return resultobj;
46098 fail:
46099 return NULL;
46100 }
46101
46102
46103 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46104 PyObject *resultobj = 0;
46105 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46106 int result;
46107 void *argp1 = 0 ;
46108 int res1 = 0 ;
46109 PyObject *swig_obj[1] ;
46110
46111 if (!args) SWIG_fail;
46112 swig_obj[0] = args;
46113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46114 if (!SWIG_IsOK(res1)) {
46115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46116 }
46117 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46118 {
46119 PyThreadState* __tstate = wxPyBeginAllowThreads();
46120 result = (int)(arg1)->GetFlag();
46121 wxPyEndAllowThreads(__tstate);
46122 if (PyErr_Occurred()) SWIG_fail;
46123 }
46124 resultobj = SWIG_From_int(static_cast< int >(result));
46125 return resultobj;
46126 fail:
46127 return NULL;
46128 }
46129
46130
46131 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46132 PyObject *resultobj = 0;
46133 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46134 int arg2 ;
46135 void *argp1 = 0 ;
46136 int res1 = 0 ;
46137 int val2 ;
46138 int ecode2 = 0 ;
46139 PyObject * obj0 = 0 ;
46140 PyObject * obj1 = 0 ;
46141 char * kwnames[] = {
46142 (char *) "self",(char *) "border", NULL
46143 };
46144
46145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
46146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46147 if (!SWIG_IsOK(res1)) {
46148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46149 }
46150 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46151 ecode2 = SWIG_AsVal_int(obj1, &val2);
46152 if (!SWIG_IsOK(ecode2)) {
46153 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
46154 }
46155 arg2 = static_cast< int >(val2);
46156 {
46157 PyThreadState* __tstate = wxPyBeginAllowThreads();
46158 (arg1)->SetBorder(arg2);
46159 wxPyEndAllowThreads(__tstate);
46160 if (PyErr_Occurred()) SWIG_fail;
46161 }
46162 resultobj = SWIG_Py_Void();
46163 return resultobj;
46164 fail:
46165 return NULL;
46166 }
46167
46168
46169 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46170 PyObject *resultobj = 0;
46171 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46172 int result;
46173 void *argp1 = 0 ;
46174 int res1 = 0 ;
46175 PyObject *swig_obj[1] ;
46176
46177 if (!args) SWIG_fail;
46178 swig_obj[0] = args;
46179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46180 if (!SWIG_IsOK(res1)) {
46181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46182 }
46183 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46184 {
46185 PyThreadState* __tstate = wxPyBeginAllowThreads();
46186 result = (int)(arg1)->GetBorder();
46187 wxPyEndAllowThreads(__tstate);
46188 if (PyErr_Occurred()) SWIG_fail;
46189 }
46190 resultobj = SWIG_From_int(static_cast< int >(result));
46191 return resultobj;
46192 fail:
46193 return NULL;
46194 }
46195
46196
46197 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46198 PyObject *resultobj = 0;
46199 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46200 wxWindow *result = 0 ;
46201 void *argp1 = 0 ;
46202 int res1 = 0 ;
46203 PyObject *swig_obj[1] ;
46204
46205 if (!args) SWIG_fail;
46206 swig_obj[0] = args;
46207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46208 if (!SWIG_IsOK(res1)) {
46209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46210 }
46211 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46212 {
46213 PyThreadState* __tstate = wxPyBeginAllowThreads();
46214 result = (wxWindow *)(arg1)->GetWindow();
46215 wxPyEndAllowThreads(__tstate);
46216 if (PyErr_Occurred()) SWIG_fail;
46217 }
46218 {
46219 resultobj = wxPyMake_wxObject(result, 0);
46220 }
46221 return resultobj;
46222 fail:
46223 return NULL;
46224 }
46225
46226
46227 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46228 PyObject *resultobj = 0;
46229 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46230 wxWindow *arg2 = (wxWindow *) 0 ;
46231 void *argp1 = 0 ;
46232 int res1 = 0 ;
46233 void *argp2 = 0 ;
46234 int res2 = 0 ;
46235 PyObject * obj0 = 0 ;
46236 PyObject * obj1 = 0 ;
46237 char * kwnames[] = {
46238 (char *) "self",(char *) "window", NULL
46239 };
46240
46241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
46242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46243 if (!SWIG_IsOK(res1)) {
46244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46245 }
46246 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46247 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46248 if (!SWIG_IsOK(res2)) {
46249 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
46250 }
46251 arg2 = reinterpret_cast< wxWindow * >(argp2);
46252 {
46253 PyThreadState* __tstate = wxPyBeginAllowThreads();
46254 (arg1)->SetWindow(arg2);
46255 wxPyEndAllowThreads(__tstate);
46256 if (PyErr_Occurred()) SWIG_fail;
46257 }
46258 resultobj = SWIG_Py_Void();
46259 return resultobj;
46260 fail:
46261 return NULL;
46262 }
46263
46264
46265 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46266 PyObject *resultobj = 0;
46267 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46268 wxSizer *result = 0 ;
46269 void *argp1 = 0 ;
46270 int res1 = 0 ;
46271 PyObject *swig_obj[1] ;
46272
46273 if (!args) SWIG_fail;
46274 swig_obj[0] = args;
46275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46276 if (!SWIG_IsOK(res1)) {
46277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46278 }
46279 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46280 {
46281 PyThreadState* __tstate = wxPyBeginAllowThreads();
46282 result = (wxSizer *)(arg1)->GetSizer();
46283 wxPyEndAllowThreads(__tstate);
46284 if (PyErr_Occurred()) SWIG_fail;
46285 }
46286 {
46287 resultobj = wxPyMake_wxObject(result, (bool)0);
46288 }
46289 return resultobj;
46290 fail:
46291 return NULL;
46292 }
46293
46294
46295 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46296 PyObject *resultobj = 0;
46297 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46298 wxSizer *arg2 = (wxSizer *) 0 ;
46299 void *argp1 = 0 ;
46300 int res1 = 0 ;
46301 int res2 = 0 ;
46302 PyObject * obj0 = 0 ;
46303 PyObject * obj1 = 0 ;
46304 char * kwnames[] = {
46305 (char *) "self",(char *) "sizer", NULL
46306 };
46307
46308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
46309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46310 if (!SWIG_IsOK(res1)) {
46311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46312 }
46313 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46314 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46315 if (!SWIG_IsOK(res2)) {
46316 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
46317 }
46318 {
46319 PyThreadState* __tstate = wxPyBeginAllowThreads();
46320 (arg1)->SetSizer(arg2);
46321 wxPyEndAllowThreads(__tstate);
46322 if (PyErr_Occurred()) SWIG_fail;
46323 }
46324 resultobj = SWIG_Py_Void();
46325 return resultobj;
46326 fail:
46327 return NULL;
46328 }
46329
46330
46331 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46332 PyObject *resultobj = 0;
46333 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46334 wxSize *result = 0 ;
46335 void *argp1 = 0 ;
46336 int res1 = 0 ;
46337 PyObject *swig_obj[1] ;
46338
46339 if (!args) SWIG_fail;
46340 swig_obj[0] = args;
46341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46342 if (!SWIG_IsOK(res1)) {
46343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46344 }
46345 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46346 {
46347 PyThreadState* __tstate = wxPyBeginAllowThreads();
46348 {
46349 wxSize const &_result_ref = (arg1)->GetSpacer();
46350 result = (wxSize *) &_result_ref;
46351 }
46352 wxPyEndAllowThreads(__tstate);
46353 if (PyErr_Occurred()) SWIG_fail;
46354 }
46355 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
46356 return resultobj;
46357 fail:
46358 return NULL;
46359 }
46360
46361
46362 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46363 PyObject *resultobj = 0;
46364 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46365 wxSize *arg2 = 0 ;
46366 void *argp1 = 0 ;
46367 int res1 = 0 ;
46368 wxSize temp2 ;
46369 PyObject * obj0 = 0 ;
46370 PyObject * obj1 = 0 ;
46371 char * kwnames[] = {
46372 (char *) "self",(char *) "size", NULL
46373 };
46374
46375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
46376 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46377 if (!SWIG_IsOK(res1)) {
46378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46379 }
46380 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46381 {
46382 arg2 = &temp2;
46383 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46384 }
46385 {
46386 PyThreadState* __tstate = wxPyBeginAllowThreads();
46387 (arg1)->SetSpacer((wxSize const &)*arg2);
46388 wxPyEndAllowThreads(__tstate);
46389 if (PyErr_Occurred()) SWIG_fail;
46390 }
46391 resultobj = SWIG_Py_Void();
46392 return resultobj;
46393 fail:
46394 return NULL;
46395 }
46396
46397
46398 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46399 PyObject *resultobj = 0;
46400 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46401 bool arg2 ;
46402 void *argp1 = 0 ;
46403 int res1 = 0 ;
46404 bool val2 ;
46405 int ecode2 = 0 ;
46406 PyObject * obj0 = 0 ;
46407 PyObject * obj1 = 0 ;
46408 char * kwnames[] = {
46409 (char *) "self",(char *) "show", NULL
46410 };
46411
46412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
46413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46414 if (!SWIG_IsOK(res1)) {
46415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46416 }
46417 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46418 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46419 if (!SWIG_IsOK(ecode2)) {
46420 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
46421 }
46422 arg2 = static_cast< bool >(val2);
46423 {
46424 PyThreadState* __tstate = wxPyBeginAllowThreads();
46425 (arg1)->Show(arg2);
46426 wxPyEndAllowThreads(__tstate);
46427 if (PyErr_Occurred()) SWIG_fail;
46428 }
46429 resultobj = SWIG_Py_Void();
46430 return resultobj;
46431 fail:
46432 return NULL;
46433 }
46434
46435
46436 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46437 PyObject *resultobj = 0;
46438 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46439 bool result;
46440 void *argp1 = 0 ;
46441 int res1 = 0 ;
46442 PyObject *swig_obj[1] ;
46443
46444 if (!args) SWIG_fail;
46445 swig_obj[0] = args;
46446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46447 if (!SWIG_IsOK(res1)) {
46448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46449 }
46450 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46451 {
46452 PyThreadState* __tstate = wxPyBeginAllowThreads();
46453 result = (bool)(arg1)->IsShown();
46454 wxPyEndAllowThreads(__tstate);
46455 if (PyErr_Occurred()) SWIG_fail;
46456 }
46457 {
46458 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46459 }
46460 return resultobj;
46461 fail:
46462 return NULL;
46463 }
46464
46465
46466 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46467 PyObject *resultobj = 0;
46468 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46469 wxPoint result;
46470 void *argp1 = 0 ;
46471 int res1 = 0 ;
46472 PyObject *swig_obj[1] ;
46473
46474 if (!args) SWIG_fail;
46475 swig_obj[0] = args;
46476 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46477 if (!SWIG_IsOK(res1)) {
46478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46479 }
46480 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46481 {
46482 PyThreadState* __tstate = wxPyBeginAllowThreads();
46483 result = (arg1)->GetPosition();
46484 wxPyEndAllowThreads(__tstate);
46485 if (PyErr_Occurred()) SWIG_fail;
46486 }
46487 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46488 return resultobj;
46489 fail:
46490 return NULL;
46491 }
46492
46493
46494 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46495 PyObject *resultobj = 0;
46496 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46497 PyObject *result = 0 ;
46498 void *argp1 = 0 ;
46499 int res1 = 0 ;
46500 PyObject *swig_obj[1] ;
46501
46502 if (!args) SWIG_fail;
46503 swig_obj[0] = args;
46504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46505 if (!SWIG_IsOK(res1)) {
46506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46507 }
46508 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46509 {
46510 PyThreadState* __tstate = wxPyBeginAllowThreads();
46511 result = (PyObject *)wxSizerItem_GetUserData(arg1);
46512 wxPyEndAllowThreads(__tstate);
46513 if (PyErr_Occurred()) SWIG_fail;
46514 }
46515 resultobj = result;
46516 return resultobj;
46517 fail:
46518 return NULL;
46519 }
46520
46521
46522 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46523 PyObject *resultobj = 0;
46524 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46525 PyObject *arg2 = (PyObject *) 0 ;
46526 void *argp1 = 0 ;
46527 int res1 = 0 ;
46528 PyObject * obj0 = 0 ;
46529 PyObject * obj1 = 0 ;
46530 char * kwnames[] = {
46531 (char *) "self",(char *) "userData", NULL
46532 };
46533
46534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
46535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46536 if (!SWIG_IsOK(res1)) {
46537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46538 }
46539 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46540 arg2 = obj1;
46541 {
46542 PyThreadState* __tstate = wxPyBeginAllowThreads();
46543 wxSizerItem_SetUserData(arg1,arg2);
46544 wxPyEndAllowThreads(__tstate);
46545 if (PyErr_Occurred()) SWIG_fail;
46546 }
46547 resultobj = SWIG_Py_Void();
46548 return resultobj;
46549 fail:
46550 return NULL;
46551 }
46552
46553
46554 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46555 PyObject *obj;
46556 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46557 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
46558 return SWIG_Py_Void();
46559 }
46560
46561 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46562 return SWIG_Python_InitShadowInstance(args);
46563 }
46564
46565 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46566 PyObject *resultobj = 0;
46567 wxSizer *arg1 = (wxSizer *) 0 ;
46568 void *argp1 = 0 ;
46569 int res1 = 0 ;
46570 PyObject *swig_obj[1] ;
46571
46572 if (!args) SWIG_fail;
46573 swig_obj[0] = args;
46574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46575 if (!SWIG_IsOK(res1)) {
46576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
46577 }
46578 arg1 = reinterpret_cast< wxSizer * >(argp1);
46579 {
46580 PyThreadState* __tstate = wxPyBeginAllowThreads();
46581 delete arg1;
46582
46583 wxPyEndAllowThreads(__tstate);
46584 if (PyErr_Occurred()) SWIG_fail;
46585 }
46586 resultobj = SWIG_Py_Void();
46587 return resultobj;
46588 fail:
46589 return NULL;
46590 }
46591
46592
46593 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46594 PyObject *resultobj = 0;
46595 wxSizer *arg1 = (wxSizer *) 0 ;
46596 PyObject *arg2 = (PyObject *) 0 ;
46597 void *argp1 = 0 ;
46598 int res1 = 0 ;
46599 PyObject * obj0 = 0 ;
46600 PyObject * obj1 = 0 ;
46601 char * kwnames[] = {
46602 (char *) "self",(char *) "_self", NULL
46603 };
46604
46605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
46606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46607 if (!SWIG_IsOK(res1)) {
46608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
46609 }
46610 arg1 = reinterpret_cast< wxSizer * >(argp1);
46611 arg2 = obj1;
46612 {
46613 PyThreadState* __tstate = wxPyBeginAllowThreads();
46614 wxSizer__setOORInfo(arg1,arg2);
46615 wxPyEndAllowThreads(__tstate);
46616 if (PyErr_Occurred()) SWIG_fail;
46617 }
46618 resultobj = SWIG_Py_Void();
46619 return resultobj;
46620 fail:
46621 return NULL;
46622 }
46623
46624
46625 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46626 PyObject *resultobj = 0;
46627 wxSizer *arg1 = (wxSizer *) 0 ;
46628 PyObject *arg2 = (PyObject *) 0 ;
46629 int arg3 = (int) 0 ;
46630 int arg4 = (int) 0 ;
46631 int arg5 = (int) 0 ;
46632 PyObject *arg6 = (PyObject *) NULL ;
46633 wxSizerItem *result = 0 ;
46634 void *argp1 = 0 ;
46635 int res1 = 0 ;
46636 int val3 ;
46637 int ecode3 = 0 ;
46638 int val4 ;
46639 int ecode4 = 0 ;
46640 int val5 ;
46641 int ecode5 = 0 ;
46642 PyObject * obj0 = 0 ;
46643 PyObject * obj1 = 0 ;
46644 PyObject * obj2 = 0 ;
46645 PyObject * obj3 = 0 ;
46646 PyObject * obj4 = 0 ;
46647 PyObject * obj5 = 0 ;
46648 char * kwnames[] = {
46649 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46650 };
46651
46652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46654 if (!SWIG_IsOK(res1)) {
46655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
46656 }
46657 arg1 = reinterpret_cast< wxSizer * >(argp1);
46658 arg2 = obj1;
46659 if (obj2) {
46660 ecode3 = SWIG_AsVal_int(obj2, &val3);
46661 if (!SWIG_IsOK(ecode3)) {
46662 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
46663 }
46664 arg3 = static_cast< int >(val3);
46665 }
46666 if (obj3) {
46667 ecode4 = SWIG_AsVal_int(obj3, &val4);
46668 if (!SWIG_IsOK(ecode4)) {
46669 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
46670 }
46671 arg4 = static_cast< int >(val4);
46672 }
46673 if (obj4) {
46674 ecode5 = SWIG_AsVal_int(obj4, &val5);
46675 if (!SWIG_IsOK(ecode5)) {
46676 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
46677 }
46678 arg5 = static_cast< int >(val5);
46679 }
46680 if (obj5) {
46681 arg6 = obj5;
46682 }
46683 {
46684 PyThreadState* __tstate = wxPyBeginAllowThreads();
46685 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
46686 wxPyEndAllowThreads(__tstate);
46687 if (PyErr_Occurred()) SWIG_fail;
46688 }
46689 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46690 return resultobj;
46691 fail:
46692 return NULL;
46693 }
46694
46695
46696 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46697 PyObject *resultobj = 0;
46698 wxSizer *arg1 = (wxSizer *) 0 ;
46699 int arg2 ;
46700 PyObject *arg3 = (PyObject *) 0 ;
46701 int arg4 = (int) 0 ;
46702 int arg5 = (int) 0 ;
46703 int arg6 = (int) 0 ;
46704 PyObject *arg7 = (PyObject *) NULL ;
46705 wxSizerItem *result = 0 ;
46706 void *argp1 = 0 ;
46707 int res1 = 0 ;
46708 int val2 ;
46709 int ecode2 = 0 ;
46710 int val4 ;
46711 int ecode4 = 0 ;
46712 int val5 ;
46713 int ecode5 = 0 ;
46714 int val6 ;
46715 int ecode6 = 0 ;
46716 PyObject * obj0 = 0 ;
46717 PyObject * obj1 = 0 ;
46718 PyObject * obj2 = 0 ;
46719 PyObject * obj3 = 0 ;
46720 PyObject * obj4 = 0 ;
46721 PyObject * obj5 = 0 ;
46722 PyObject * obj6 = 0 ;
46723 char * kwnames[] = {
46724 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46725 };
46726
46727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
46728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46729 if (!SWIG_IsOK(res1)) {
46730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
46731 }
46732 arg1 = reinterpret_cast< wxSizer * >(argp1);
46733 ecode2 = SWIG_AsVal_int(obj1, &val2);
46734 if (!SWIG_IsOK(ecode2)) {
46735 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
46736 }
46737 arg2 = static_cast< int >(val2);
46738 arg3 = obj2;
46739 if (obj3) {
46740 ecode4 = SWIG_AsVal_int(obj3, &val4);
46741 if (!SWIG_IsOK(ecode4)) {
46742 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
46743 }
46744 arg4 = static_cast< int >(val4);
46745 }
46746 if (obj4) {
46747 ecode5 = SWIG_AsVal_int(obj4, &val5);
46748 if (!SWIG_IsOK(ecode5)) {
46749 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
46750 }
46751 arg5 = static_cast< int >(val5);
46752 }
46753 if (obj5) {
46754 ecode6 = SWIG_AsVal_int(obj5, &val6);
46755 if (!SWIG_IsOK(ecode6)) {
46756 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
46757 }
46758 arg6 = static_cast< int >(val6);
46759 }
46760 if (obj6) {
46761 arg7 = obj6;
46762 }
46763 {
46764 PyThreadState* __tstate = wxPyBeginAllowThreads();
46765 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
46766 wxPyEndAllowThreads(__tstate);
46767 if (PyErr_Occurred()) SWIG_fail;
46768 }
46769 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46770 return resultobj;
46771 fail:
46772 return NULL;
46773 }
46774
46775
46776 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46777 PyObject *resultobj = 0;
46778 wxSizer *arg1 = (wxSizer *) 0 ;
46779 PyObject *arg2 = (PyObject *) 0 ;
46780 int arg3 = (int) 0 ;
46781 int arg4 = (int) 0 ;
46782 int arg5 = (int) 0 ;
46783 PyObject *arg6 = (PyObject *) NULL ;
46784 wxSizerItem *result = 0 ;
46785 void *argp1 = 0 ;
46786 int res1 = 0 ;
46787 int val3 ;
46788 int ecode3 = 0 ;
46789 int val4 ;
46790 int ecode4 = 0 ;
46791 int val5 ;
46792 int ecode5 = 0 ;
46793 PyObject * obj0 = 0 ;
46794 PyObject * obj1 = 0 ;
46795 PyObject * obj2 = 0 ;
46796 PyObject * obj3 = 0 ;
46797 PyObject * obj4 = 0 ;
46798 PyObject * obj5 = 0 ;
46799 char * kwnames[] = {
46800 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46801 };
46802
46803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46805 if (!SWIG_IsOK(res1)) {
46806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
46807 }
46808 arg1 = reinterpret_cast< wxSizer * >(argp1);
46809 arg2 = obj1;
46810 if (obj2) {
46811 ecode3 = SWIG_AsVal_int(obj2, &val3);
46812 if (!SWIG_IsOK(ecode3)) {
46813 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
46814 }
46815 arg3 = static_cast< int >(val3);
46816 }
46817 if (obj3) {
46818 ecode4 = SWIG_AsVal_int(obj3, &val4);
46819 if (!SWIG_IsOK(ecode4)) {
46820 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
46821 }
46822 arg4 = static_cast< int >(val4);
46823 }
46824 if (obj4) {
46825 ecode5 = SWIG_AsVal_int(obj4, &val5);
46826 if (!SWIG_IsOK(ecode5)) {
46827 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
46828 }
46829 arg5 = static_cast< int >(val5);
46830 }
46831 if (obj5) {
46832 arg6 = obj5;
46833 }
46834 {
46835 PyThreadState* __tstate = wxPyBeginAllowThreads();
46836 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
46837 wxPyEndAllowThreads(__tstate);
46838 if (PyErr_Occurred()) SWIG_fail;
46839 }
46840 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46841 return resultobj;
46842 fail:
46843 return NULL;
46844 }
46845
46846
46847 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46848 PyObject *resultobj = 0;
46849 wxSizer *arg1 = (wxSizer *) 0 ;
46850 PyObject *arg2 = (PyObject *) 0 ;
46851 bool result;
46852 void *argp1 = 0 ;
46853 int res1 = 0 ;
46854 PyObject * obj0 = 0 ;
46855 PyObject * obj1 = 0 ;
46856 char * kwnames[] = {
46857 (char *) "self",(char *) "item", NULL
46858 };
46859
46860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
46861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46862 if (!SWIG_IsOK(res1)) {
46863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
46864 }
46865 arg1 = reinterpret_cast< wxSizer * >(argp1);
46866 arg2 = obj1;
46867 {
46868 PyThreadState* __tstate = wxPyBeginAllowThreads();
46869 result = (bool)wxSizer_Remove(arg1,arg2);
46870 wxPyEndAllowThreads(__tstate);
46871 if (PyErr_Occurred()) SWIG_fail;
46872 }
46873 {
46874 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46875 }
46876 return resultobj;
46877 fail:
46878 return NULL;
46879 }
46880
46881
46882 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46883 PyObject *resultobj = 0;
46884 wxSizer *arg1 = (wxSizer *) 0 ;
46885 PyObject *arg2 = (PyObject *) 0 ;
46886 bool result;
46887 void *argp1 = 0 ;
46888 int res1 = 0 ;
46889 PyObject * obj0 = 0 ;
46890 PyObject * obj1 = 0 ;
46891 char * kwnames[] = {
46892 (char *) "self",(char *) "item", NULL
46893 };
46894
46895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
46896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46897 if (!SWIG_IsOK(res1)) {
46898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
46899 }
46900 arg1 = reinterpret_cast< wxSizer * >(argp1);
46901 arg2 = obj1;
46902 {
46903 PyThreadState* __tstate = wxPyBeginAllowThreads();
46904 result = (bool)wxSizer_Detach(arg1,arg2);
46905 wxPyEndAllowThreads(__tstate);
46906 if (PyErr_Occurred()) SWIG_fail;
46907 }
46908 {
46909 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46910 }
46911 return resultobj;
46912 fail:
46913 return NULL;
46914 }
46915
46916
46917 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46918 PyObject *resultobj = 0;
46919 wxSizer *arg1 = (wxSizer *) 0 ;
46920 PyObject *arg2 = (PyObject *) 0 ;
46921 wxSizerItem *result = 0 ;
46922 void *argp1 = 0 ;
46923 int res1 = 0 ;
46924 PyObject * obj0 = 0 ;
46925 PyObject * obj1 = 0 ;
46926 char * kwnames[] = {
46927 (char *) "self",(char *) "item", NULL
46928 };
46929
46930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
46931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46932 if (!SWIG_IsOK(res1)) {
46933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46934 }
46935 arg1 = reinterpret_cast< wxSizer * >(argp1);
46936 arg2 = obj1;
46937 {
46938 PyThreadState* __tstate = wxPyBeginAllowThreads();
46939 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
46940 wxPyEndAllowThreads(__tstate);
46941 if (PyErr_Occurred()) SWIG_fail;
46942 }
46943 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46944 return resultobj;
46945 fail:
46946 return NULL;
46947 }
46948
46949
46950 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46951 PyObject *resultobj = 0;
46952 wxSizer *arg1 = (wxSizer *) 0 ;
46953 PyObject *arg2 = (PyObject *) 0 ;
46954 wxSize *arg3 = 0 ;
46955 void *argp1 = 0 ;
46956 int res1 = 0 ;
46957 wxSize temp3 ;
46958 PyObject * obj0 = 0 ;
46959 PyObject * obj1 = 0 ;
46960 PyObject * obj2 = 0 ;
46961 char * kwnames[] = {
46962 (char *) "self",(char *) "item",(char *) "size", NULL
46963 };
46964
46965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46967 if (!SWIG_IsOK(res1)) {
46968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46969 }
46970 arg1 = reinterpret_cast< wxSizer * >(argp1);
46971 arg2 = obj1;
46972 {
46973 arg3 = &temp3;
46974 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46975 }
46976 {
46977 PyThreadState* __tstate = wxPyBeginAllowThreads();
46978 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
46979 wxPyEndAllowThreads(__tstate);
46980 if (PyErr_Occurred()) SWIG_fail;
46981 }
46982 resultobj = SWIG_Py_Void();
46983 return resultobj;
46984 fail:
46985 return NULL;
46986 }
46987
46988
46989 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46990 PyObject *resultobj = 0;
46991 wxSizer *arg1 = (wxSizer *) 0 ;
46992 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46993 wxSizerItem *result = 0 ;
46994 void *argp1 = 0 ;
46995 int res1 = 0 ;
46996 int res2 = 0 ;
46997 PyObject * obj0 = 0 ;
46998 PyObject * obj1 = 0 ;
46999 char * kwnames[] = {
47000 (char *) "self",(char *) "item", NULL
47001 };
47002
47003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
47004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47005 if (!SWIG_IsOK(res1)) {
47006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47007 }
47008 arg1 = reinterpret_cast< wxSizer * >(argp1);
47009 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47010 if (!SWIG_IsOK(res2)) {
47011 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
47012 }
47013 {
47014 PyThreadState* __tstate = wxPyBeginAllowThreads();
47015 result = (wxSizerItem *)(arg1)->Add(arg2);
47016 wxPyEndAllowThreads(__tstate);
47017 if (PyErr_Occurred()) SWIG_fail;
47018 }
47019 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47020 return resultobj;
47021 fail:
47022 return NULL;
47023 }
47024
47025
47026 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47027 PyObject *resultobj = 0;
47028 wxSizer *arg1 = (wxSizer *) 0 ;
47029 size_t arg2 ;
47030 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
47031 wxSizerItem *result = 0 ;
47032 void *argp1 = 0 ;
47033 int res1 = 0 ;
47034 size_t val2 ;
47035 int ecode2 = 0 ;
47036 int res3 = 0 ;
47037 PyObject * obj0 = 0 ;
47038 PyObject * obj1 = 0 ;
47039 PyObject * obj2 = 0 ;
47040 char * kwnames[] = {
47041 (char *) "self",(char *) "index",(char *) "item", NULL
47042 };
47043
47044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47046 if (!SWIG_IsOK(res1)) {
47047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47048 }
47049 arg1 = reinterpret_cast< wxSizer * >(argp1);
47050 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47051 if (!SWIG_IsOK(ecode2)) {
47052 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
47053 }
47054 arg2 = static_cast< size_t >(val2);
47055 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47056 if (!SWIG_IsOK(res3)) {
47057 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
47058 }
47059 {
47060 PyThreadState* __tstate = wxPyBeginAllowThreads();
47061 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
47062 wxPyEndAllowThreads(__tstate);
47063 if (PyErr_Occurred()) SWIG_fail;
47064 }
47065 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47066 return resultobj;
47067 fail:
47068 return NULL;
47069 }
47070
47071
47072 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47073 PyObject *resultobj = 0;
47074 wxSizer *arg1 = (wxSizer *) 0 ;
47075 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
47076 wxSizerItem *result = 0 ;
47077 void *argp1 = 0 ;
47078 int res1 = 0 ;
47079 int res2 = 0 ;
47080 PyObject * obj0 = 0 ;
47081 PyObject * obj1 = 0 ;
47082 char * kwnames[] = {
47083 (char *) "self",(char *) "item", NULL
47084 };
47085
47086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
47087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47088 if (!SWIG_IsOK(res1)) {
47089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47090 }
47091 arg1 = reinterpret_cast< wxSizer * >(argp1);
47092 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47093 if (!SWIG_IsOK(res2)) {
47094 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
47095 }
47096 {
47097 PyThreadState* __tstate = wxPyBeginAllowThreads();
47098 result = (wxSizerItem *)(arg1)->Prepend(arg2);
47099 wxPyEndAllowThreads(__tstate);
47100 if (PyErr_Occurred()) SWIG_fail;
47101 }
47102 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47103 return resultobj;
47104 fail:
47105 return NULL;
47106 }
47107
47108
47109 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47110 PyObject *resultobj = 0;
47111 wxSizer *arg1 = (wxSizer *) 0 ;
47112 int arg2 ;
47113 int arg3 ;
47114 int arg4 ;
47115 int arg5 ;
47116 void *argp1 = 0 ;
47117 int res1 = 0 ;
47118 int val2 ;
47119 int ecode2 = 0 ;
47120 int val3 ;
47121 int ecode3 = 0 ;
47122 int val4 ;
47123 int ecode4 = 0 ;
47124 int val5 ;
47125 int ecode5 = 0 ;
47126 PyObject * obj0 = 0 ;
47127 PyObject * obj1 = 0 ;
47128 PyObject * obj2 = 0 ;
47129 PyObject * obj3 = 0 ;
47130 PyObject * obj4 = 0 ;
47131 char * kwnames[] = {
47132 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
47133 };
47134
47135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
47136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47137 if (!SWIG_IsOK(res1)) {
47138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
47139 }
47140 arg1 = reinterpret_cast< wxSizer * >(argp1);
47141 ecode2 = SWIG_AsVal_int(obj1, &val2);
47142 if (!SWIG_IsOK(ecode2)) {
47143 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
47144 }
47145 arg2 = static_cast< int >(val2);
47146 ecode3 = SWIG_AsVal_int(obj2, &val3);
47147 if (!SWIG_IsOK(ecode3)) {
47148 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
47149 }
47150 arg3 = static_cast< int >(val3);
47151 ecode4 = SWIG_AsVal_int(obj3, &val4);
47152 if (!SWIG_IsOK(ecode4)) {
47153 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
47154 }
47155 arg4 = static_cast< int >(val4);
47156 ecode5 = SWIG_AsVal_int(obj4, &val5);
47157 if (!SWIG_IsOK(ecode5)) {
47158 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
47159 }
47160 arg5 = static_cast< int >(val5);
47161 {
47162 PyThreadState* __tstate = wxPyBeginAllowThreads();
47163 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
47164 wxPyEndAllowThreads(__tstate);
47165 if (PyErr_Occurred()) SWIG_fail;
47166 }
47167 resultobj = SWIG_Py_Void();
47168 return resultobj;
47169 fail:
47170 return NULL;
47171 }
47172
47173
47174 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47175 PyObject *resultobj = 0;
47176 wxSizer *arg1 = (wxSizer *) 0 ;
47177 wxSize *arg2 = 0 ;
47178 void *argp1 = 0 ;
47179 int res1 = 0 ;
47180 wxSize temp2 ;
47181 PyObject * obj0 = 0 ;
47182 PyObject * obj1 = 0 ;
47183 char * kwnames[] = {
47184 (char *) "self",(char *) "size", NULL
47185 };
47186
47187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
47188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47189 if (!SWIG_IsOK(res1)) {
47190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47191 }
47192 arg1 = reinterpret_cast< wxSizer * >(argp1);
47193 {
47194 arg2 = &temp2;
47195 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
47196 }
47197 {
47198 PyThreadState* __tstate = wxPyBeginAllowThreads();
47199 (arg1)->SetMinSize((wxSize const &)*arg2);
47200 wxPyEndAllowThreads(__tstate);
47201 if (PyErr_Occurred()) SWIG_fail;
47202 }
47203 resultobj = SWIG_Py_Void();
47204 return resultobj;
47205 fail:
47206 return NULL;
47207 }
47208
47209
47210 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47211 PyObject *resultobj = 0;
47212 wxSizer *arg1 = (wxSizer *) 0 ;
47213 wxSize result;
47214 void *argp1 = 0 ;
47215 int res1 = 0 ;
47216 PyObject *swig_obj[1] ;
47217
47218 if (!args) SWIG_fail;
47219 swig_obj[0] = args;
47220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47221 if (!SWIG_IsOK(res1)) {
47222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47223 }
47224 arg1 = reinterpret_cast< wxSizer * >(argp1);
47225 {
47226 PyThreadState* __tstate = wxPyBeginAllowThreads();
47227 result = (arg1)->GetSize();
47228 wxPyEndAllowThreads(__tstate);
47229 if (PyErr_Occurred()) SWIG_fail;
47230 }
47231 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47232 return resultobj;
47233 fail:
47234 return NULL;
47235 }
47236
47237
47238 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47239 PyObject *resultobj = 0;
47240 wxSizer *arg1 = (wxSizer *) 0 ;
47241 wxPoint result;
47242 void *argp1 = 0 ;
47243 int res1 = 0 ;
47244 PyObject *swig_obj[1] ;
47245
47246 if (!args) SWIG_fail;
47247 swig_obj[0] = args;
47248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47249 if (!SWIG_IsOK(res1)) {
47250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
47251 }
47252 arg1 = reinterpret_cast< wxSizer * >(argp1);
47253 {
47254 PyThreadState* __tstate = wxPyBeginAllowThreads();
47255 result = (arg1)->GetPosition();
47256 wxPyEndAllowThreads(__tstate);
47257 if (PyErr_Occurred()) SWIG_fail;
47258 }
47259 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
47260 return resultobj;
47261 fail:
47262 return NULL;
47263 }
47264
47265
47266 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47267 PyObject *resultobj = 0;
47268 wxSizer *arg1 = (wxSizer *) 0 ;
47269 wxSize result;
47270 void *argp1 = 0 ;
47271 int res1 = 0 ;
47272 PyObject *swig_obj[1] ;
47273
47274 if (!args) SWIG_fail;
47275 swig_obj[0] = args;
47276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47277 if (!SWIG_IsOK(res1)) {
47278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47279 }
47280 arg1 = reinterpret_cast< wxSizer * >(argp1);
47281 {
47282 PyThreadState* __tstate = wxPyBeginAllowThreads();
47283 result = (arg1)->GetMinSize();
47284 wxPyEndAllowThreads(__tstate);
47285 if (PyErr_Occurred()) SWIG_fail;
47286 }
47287 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47288 return resultobj;
47289 fail:
47290 return NULL;
47291 }
47292
47293
47294 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47295 PyObject *resultobj = 0;
47296 wxSizer *arg1 = (wxSizer *) 0 ;
47297 void *argp1 = 0 ;
47298 int res1 = 0 ;
47299 PyObject *swig_obj[1] ;
47300
47301 if (!args) SWIG_fail;
47302 swig_obj[0] = args;
47303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47304 if (!SWIG_IsOK(res1)) {
47305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
47306 }
47307 arg1 = reinterpret_cast< wxSizer * >(argp1);
47308 {
47309 PyThreadState* __tstate = wxPyBeginAllowThreads();
47310 (arg1)->RecalcSizes();
47311 wxPyEndAllowThreads(__tstate);
47312 if (PyErr_Occurred()) SWIG_fail;
47313 }
47314 resultobj = SWIG_Py_Void();
47315 return resultobj;
47316 fail:
47317 return NULL;
47318 }
47319
47320
47321 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47322 PyObject *resultobj = 0;
47323 wxSizer *arg1 = (wxSizer *) 0 ;
47324 wxSize result;
47325 void *argp1 = 0 ;
47326 int res1 = 0 ;
47327 PyObject *swig_obj[1] ;
47328
47329 if (!args) SWIG_fail;
47330 swig_obj[0] = args;
47331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47332 if (!SWIG_IsOK(res1)) {
47333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
47334 }
47335 arg1 = reinterpret_cast< wxSizer * >(argp1);
47336 {
47337 PyThreadState* __tstate = wxPyBeginAllowThreads();
47338 result = (arg1)->CalcMin();
47339 wxPyEndAllowThreads(__tstate);
47340 if (PyErr_Occurred()) SWIG_fail;
47341 }
47342 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47343 return resultobj;
47344 fail:
47345 return NULL;
47346 }
47347
47348
47349 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47350 PyObject *resultobj = 0;
47351 wxSizer *arg1 = (wxSizer *) 0 ;
47352 void *argp1 = 0 ;
47353 int res1 = 0 ;
47354 PyObject *swig_obj[1] ;
47355
47356 if (!args) SWIG_fail;
47357 swig_obj[0] = args;
47358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47359 if (!SWIG_IsOK(res1)) {
47360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
47361 }
47362 arg1 = reinterpret_cast< wxSizer * >(argp1);
47363 {
47364 PyThreadState* __tstate = wxPyBeginAllowThreads();
47365 (arg1)->Layout();
47366 wxPyEndAllowThreads(__tstate);
47367 if (PyErr_Occurred()) SWIG_fail;
47368 }
47369 resultobj = SWIG_Py_Void();
47370 return resultobj;
47371 fail:
47372 return NULL;
47373 }
47374
47375
47376 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47377 PyObject *resultobj = 0;
47378 wxSizer *arg1 = (wxSizer *) 0 ;
47379 wxWindow *arg2 = (wxWindow *) 0 ;
47380 wxSize result;
47381 void *argp1 = 0 ;
47382 int res1 = 0 ;
47383 void *argp2 = 0 ;
47384 int res2 = 0 ;
47385 PyObject * obj0 = 0 ;
47386 PyObject * obj1 = 0 ;
47387 char * kwnames[] = {
47388 (char *) "self",(char *) "window", NULL
47389 };
47390
47391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
47392 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47393 if (!SWIG_IsOK(res1)) {
47394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
47395 }
47396 arg1 = reinterpret_cast< wxSizer * >(argp1);
47397 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47398 if (!SWIG_IsOK(res2)) {
47399 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
47400 }
47401 arg2 = reinterpret_cast< wxWindow * >(argp2);
47402 {
47403 PyThreadState* __tstate = wxPyBeginAllowThreads();
47404 result = (arg1)->Fit(arg2);
47405 wxPyEndAllowThreads(__tstate);
47406 if (PyErr_Occurred()) SWIG_fail;
47407 }
47408 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47409 return resultobj;
47410 fail:
47411 return NULL;
47412 }
47413
47414
47415 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47416 PyObject *resultobj = 0;
47417 wxSizer *arg1 = (wxSizer *) 0 ;
47418 wxWindow *arg2 = (wxWindow *) 0 ;
47419 void *argp1 = 0 ;
47420 int res1 = 0 ;
47421 void *argp2 = 0 ;
47422 int res2 = 0 ;
47423 PyObject * obj0 = 0 ;
47424 PyObject * obj1 = 0 ;
47425 char * kwnames[] = {
47426 (char *) "self",(char *) "window", NULL
47427 };
47428
47429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
47430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47431 if (!SWIG_IsOK(res1)) {
47432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
47433 }
47434 arg1 = reinterpret_cast< wxSizer * >(argp1);
47435 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47436 if (!SWIG_IsOK(res2)) {
47437 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
47438 }
47439 arg2 = reinterpret_cast< wxWindow * >(argp2);
47440 {
47441 PyThreadState* __tstate = wxPyBeginAllowThreads();
47442 (arg1)->FitInside(arg2);
47443 wxPyEndAllowThreads(__tstate);
47444 if (PyErr_Occurred()) SWIG_fail;
47445 }
47446 resultobj = SWIG_Py_Void();
47447 return resultobj;
47448 fail:
47449 return NULL;
47450 }
47451
47452
47453 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47454 PyObject *resultobj = 0;
47455 wxSizer *arg1 = (wxSizer *) 0 ;
47456 wxWindow *arg2 = (wxWindow *) 0 ;
47457 void *argp1 = 0 ;
47458 int res1 = 0 ;
47459 void *argp2 = 0 ;
47460 int res2 = 0 ;
47461 PyObject * obj0 = 0 ;
47462 PyObject * obj1 = 0 ;
47463 char * kwnames[] = {
47464 (char *) "self",(char *) "window", NULL
47465 };
47466
47467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",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_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47471 }
47472 arg1 = reinterpret_cast< wxSizer * >(argp1);
47473 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47474 if (!SWIG_IsOK(res2)) {
47475 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47476 }
47477 arg2 = reinterpret_cast< wxWindow * >(argp2);
47478 {
47479 PyThreadState* __tstate = wxPyBeginAllowThreads();
47480 (arg1)->SetSizeHints(arg2);
47481 wxPyEndAllowThreads(__tstate);
47482 if (PyErr_Occurred()) SWIG_fail;
47483 }
47484 resultobj = SWIG_Py_Void();
47485 return resultobj;
47486 fail:
47487 return NULL;
47488 }
47489
47490
47491 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47492 PyObject *resultobj = 0;
47493 wxSizer *arg1 = (wxSizer *) 0 ;
47494 wxWindow *arg2 = (wxWindow *) 0 ;
47495 void *argp1 = 0 ;
47496 int res1 = 0 ;
47497 void *argp2 = 0 ;
47498 int res2 = 0 ;
47499 PyObject * obj0 = 0 ;
47500 PyObject * obj1 = 0 ;
47501 char * kwnames[] = {
47502 (char *) "self",(char *) "window", NULL
47503 };
47504
47505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
47506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47507 if (!SWIG_IsOK(res1)) {
47508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47509 }
47510 arg1 = reinterpret_cast< wxSizer * >(argp1);
47511 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47512 if (!SWIG_IsOK(res2)) {
47513 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47514 }
47515 arg2 = reinterpret_cast< wxWindow * >(argp2);
47516 {
47517 PyThreadState* __tstate = wxPyBeginAllowThreads();
47518 (arg1)->SetVirtualSizeHints(arg2);
47519 wxPyEndAllowThreads(__tstate);
47520 if (PyErr_Occurred()) SWIG_fail;
47521 }
47522 resultobj = SWIG_Py_Void();
47523 return resultobj;
47524 fail:
47525 return NULL;
47526 }
47527
47528
47529 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47530 PyObject *resultobj = 0;
47531 wxSizer *arg1 = (wxSizer *) 0 ;
47532 bool arg2 = (bool) false ;
47533 void *argp1 = 0 ;
47534 int res1 = 0 ;
47535 bool val2 ;
47536 int ecode2 = 0 ;
47537 PyObject * obj0 = 0 ;
47538 PyObject * obj1 = 0 ;
47539 char * kwnames[] = {
47540 (char *) "self",(char *) "deleteWindows", NULL
47541 };
47542
47543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
47544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47545 if (!SWIG_IsOK(res1)) {
47546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
47547 }
47548 arg1 = reinterpret_cast< wxSizer * >(argp1);
47549 if (obj1) {
47550 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47551 if (!SWIG_IsOK(ecode2)) {
47552 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
47553 }
47554 arg2 = static_cast< bool >(val2);
47555 }
47556 {
47557 PyThreadState* __tstate = wxPyBeginAllowThreads();
47558 (arg1)->Clear(arg2);
47559 wxPyEndAllowThreads(__tstate);
47560 if (PyErr_Occurred()) SWIG_fail;
47561 }
47562 resultobj = SWIG_Py_Void();
47563 return resultobj;
47564 fail:
47565 return NULL;
47566 }
47567
47568
47569 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47570 PyObject *resultobj = 0;
47571 wxSizer *arg1 = (wxSizer *) 0 ;
47572 void *argp1 = 0 ;
47573 int res1 = 0 ;
47574 PyObject *swig_obj[1] ;
47575
47576 if (!args) SWIG_fail;
47577 swig_obj[0] = args;
47578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47579 if (!SWIG_IsOK(res1)) {
47580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
47581 }
47582 arg1 = reinterpret_cast< wxSizer * >(argp1);
47583 {
47584 PyThreadState* __tstate = wxPyBeginAllowThreads();
47585 (arg1)->DeleteWindows();
47586 wxPyEndAllowThreads(__tstate);
47587 if (PyErr_Occurred()) SWIG_fail;
47588 }
47589 resultobj = SWIG_Py_Void();
47590 return resultobj;
47591 fail:
47592 return NULL;
47593 }
47594
47595
47596 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47597 PyObject *resultobj = 0;
47598 wxSizer *arg1 = (wxSizer *) 0 ;
47599 PyObject *result = 0 ;
47600 void *argp1 = 0 ;
47601 int res1 = 0 ;
47602 PyObject *swig_obj[1] ;
47603
47604 if (!args) SWIG_fail;
47605 swig_obj[0] = args;
47606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47607 if (!SWIG_IsOK(res1)) {
47608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
47609 }
47610 arg1 = reinterpret_cast< wxSizer * >(argp1);
47611 {
47612 PyThreadState* __tstate = wxPyBeginAllowThreads();
47613 result = (PyObject *)wxSizer_GetChildren(arg1);
47614 wxPyEndAllowThreads(__tstate);
47615 if (PyErr_Occurred()) SWIG_fail;
47616 }
47617 resultobj = result;
47618 return resultobj;
47619 fail:
47620 return NULL;
47621 }
47622
47623
47624 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47625 PyObject *resultobj = 0;
47626 wxSizer *arg1 = (wxSizer *) 0 ;
47627 PyObject *arg2 = (PyObject *) 0 ;
47628 bool arg3 = (bool) true ;
47629 bool arg4 = (bool) false ;
47630 bool result;
47631 void *argp1 = 0 ;
47632 int res1 = 0 ;
47633 bool val3 ;
47634 int ecode3 = 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 *) "item",(char *) "show",(char *) "recursive", NULL
47643 };
47644
47645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",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_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
47649 }
47650 arg1 = reinterpret_cast< wxSizer * >(argp1);
47651 arg2 = obj1;
47652 if (obj2) {
47653 ecode3 = SWIG_AsVal_bool(obj2, &val3);
47654 if (!SWIG_IsOK(ecode3)) {
47655 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
47656 }
47657 arg3 = static_cast< bool >(val3);
47658 }
47659 if (obj3) {
47660 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47661 if (!SWIG_IsOK(ecode4)) {
47662 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
47663 }
47664 arg4 = static_cast< bool >(val4);
47665 }
47666 {
47667 PyThreadState* __tstate = wxPyBeginAllowThreads();
47668 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
47669 wxPyEndAllowThreads(__tstate);
47670 if (PyErr_Occurred()) SWIG_fail;
47671 }
47672 {
47673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47674 }
47675 return resultobj;
47676 fail:
47677 return NULL;
47678 }
47679
47680
47681 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47682 PyObject *resultobj = 0;
47683 wxSizer *arg1 = (wxSizer *) 0 ;
47684 PyObject *arg2 = (PyObject *) 0 ;
47685 bool result;
47686 void *argp1 = 0 ;
47687 int res1 = 0 ;
47688 PyObject * obj0 = 0 ;
47689 PyObject * obj1 = 0 ;
47690 char * kwnames[] = {
47691 (char *) "self",(char *) "item", NULL
47692 };
47693
47694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
47695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47696 if (!SWIG_IsOK(res1)) {
47697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
47698 }
47699 arg1 = reinterpret_cast< wxSizer * >(argp1);
47700 arg2 = obj1;
47701 {
47702 PyThreadState* __tstate = wxPyBeginAllowThreads();
47703 result = (bool)wxSizer_IsShown(arg1,arg2);
47704 wxPyEndAllowThreads(__tstate);
47705 if (PyErr_Occurred()) SWIG_fail;
47706 }
47707 {
47708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47709 }
47710 return resultobj;
47711 fail:
47712 return NULL;
47713 }
47714
47715
47716 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47717 PyObject *resultobj = 0;
47718 wxSizer *arg1 = (wxSizer *) 0 ;
47719 bool arg2 ;
47720 void *argp1 = 0 ;
47721 int res1 = 0 ;
47722 bool val2 ;
47723 int ecode2 = 0 ;
47724 PyObject * obj0 = 0 ;
47725 PyObject * obj1 = 0 ;
47726 char * kwnames[] = {
47727 (char *) "self",(char *) "show", NULL
47728 };
47729
47730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
47731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47732 if (!SWIG_IsOK(res1)) {
47733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
47734 }
47735 arg1 = reinterpret_cast< wxSizer * >(argp1);
47736 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47737 if (!SWIG_IsOK(ecode2)) {
47738 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
47739 }
47740 arg2 = static_cast< bool >(val2);
47741 {
47742 PyThreadState* __tstate = wxPyBeginAllowThreads();
47743 (arg1)->ShowItems(arg2);
47744 wxPyEndAllowThreads(__tstate);
47745 if (PyErr_Occurred()) SWIG_fail;
47746 }
47747 resultobj = SWIG_Py_Void();
47748 return resultobj;
47749 fail:
47750 return NULL;
47751 }
47752
47753
47754 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47755 PyObject *obj;
47756 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47757 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
47758 return SWIG_Py_Void();
47759 }
47760
47761 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47762 PyObject *resultobj = 0;
47763 wxPySizer *result = 0 ;
47764
47765 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
47766 {
47767 PyThreadState* __tstate = wxPyBeginAllowThreads();
47768 result = (wxPySizer *)new wxPySizer();
47769 wxPyEndAllowThreads(__tstate);
47770 if (PyErr_Occurred()) SWIG_fail;
47771 }
47772 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
47773 return resultobj;
47774 fail:
47775 return NULL;
47776 }
47777
47778
47779 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47780 PyObject *resultobj = 0;
47781 wxPySizer *arg1 = (wxPySizer *) 0 ;
47782 PyObject *arg2 = (PyObject *) 0 ;
47783 PyObject *arg3 = (PyObject *) 0 ;
47784 void *argp1 = 0 ;
47785 int res1 = 0 ;
47786 PyObject * obj0 = 0 ;
47787 PyObject * obj1 = 0 ;
47788 PyObject * obj2 = 0 ;
47789 char * kwnames[] = {
47790 (char *) "self",(char *) "self",(char *) "_class", NULL
47791 };
47792
47793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
47795 if (!SWIG_IsOK(res1)) {
47796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
47797 }
47798 arg1 = reinterpret_cast< wxPySizer * >(argp1);
47799 arg2 = obj1;
47800 arg3 = obj2;
47801 {
47802 PyThreadState* __tstate = wxPyBeginAllowThreads();
47803 (arg1)->_setCallbackInfo(arg2,arg3);
47804 wxPyEndAllowThreads(__tstate);
47805 if (PyErr_Occurred()) SWIG_fail;
47806 }
47807 resultobj = SWIG_Py_Void();
47808 return resultobj;
47809 fail:
47810 return NULL;
47811 }
47812
47813
47814 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47815 PyObject *obj;
47816 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47817 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
47818 return SWIG_Py_Void();
47819 }
47820
47821 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47822 return SWIG_Python_InitShadowInstance(args);
47823 }
47824
47825 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47826 PyObject *resultobj = 0;
47827 int arg1 = (int) wxHORIZONTAL ;
47828 wxBoxSizer *result = 0 ;
47829 int val1 ;
47830 int ecode1 = 0 ;
47831 PyObject * obj0 = 0 ;
47832 char * kwnames[] = {
47833 (char *) "orient", NULL
47834 };
47835
47836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
47837 if (obj0) {
47838 ecode1 = SWIG_AsVal_int(obj0, &val1);
47839 if (!SWIG_IsOK(ecode1)) {
47840 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
47841 }
47842 arg1 = static_cast< int >(val1);
47843 }
47844 {
47845 PyThreadState* __tstate = wxPyBeginAllowThreads();
47846 result = (wxBoxSizer *)new wxBoxSizer(arg1);
47847 wxPyEndAllowThreads(__tstate);
47848 if (PyErr_Occurred()) SWIG_fail;
47849 }
47850 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
47851 return resultobj;
47852 fail:
47853 return NULL;
47854 }
47855
47856
47857 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47858 PyObject *resultobj = 0;
47859 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47860 int result;
47861 void *argp1 = 0 ;
47862 int res1 = 0 ;
47863 PyObject *swig_obj[1] ;
47864
47865 if (!args) SWIG_fail;
47866 swig_obj[0] = args;
47867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47868 if (!SWIG_IsOK(res1)) {
47869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47870 }
47871 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47872 {
47873 PyThreadState* __tstate = wxPyBeginAllowThreads();
47874 result = (int)(arg1)->GetOrientation();
47875 wxPyEndAllowThreads(__tstate);
47876 if (PyErr_Occurred()) SWIG_fail;
47877 }
47878 resultobj = SWIG_From_int(static_cast< int >(result));
47879 return resultobj;
47880 fail:
47881 return NULL;
47882 }
47883
47884
47885 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47886 PyObject *resultobj = 0;
47887 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47888 int arg2 ;
47889 void *argp1 = 0 ;
47890 int res1 = 0 ;
47891 int val2 ;
47892 int ecode2 = 0 ;
47893 PyObject * obj0 = 0 ;
47894 PyObject * obj1 = 0 ;
47895 char * kwnames[] = {
47896 (char *) "self",(char *) "orient", NULL
47897 };
47898
47899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
47900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47901 if (!SWIG_IsOK(res1)) {
47902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47903 }
47904 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47905 ecode2 = SWIG_AsVal_int(obj1, &val2);
47906 if (!SWIG_IsOK(ecode2)) {
47907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
47908 }
47909 arg2 = static_cast< int >(val2);
47910 {
47911 PyThreadState* __tstate = wxPyBeginAllowThreads();
47912 (arg1)->SetOrientation(arg2);
47913 wxPyEndAllowThreads(__tstate);
47914 if (PyErr_Occurred()) SWIG_fail;
47915 }
47916 resultobj = SWIG_Py_Void();
47917 return resultobj;
47918 fail:
47919 return NULL;
47920 }
47921
47922
47923 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47924 PyObject *obj;
47925 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47926 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
47927 return SWIG_Py_Void();
47928 }
47929
47930 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47931 return SWIG_Python_InitShadowInstance(args);
47932 }
47933
47934 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47935 PyObject *resultobj = 0;
47936 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
47937 int arg2 = (int) wxHORIZONTAL ;
47938 wxStaticBoxSizer *result = 0 ;
47939 void *argp1 = 0 ;
47940 int res1 = 0 ;
47941 int val2 ;
47942 int ecode2 = 0 ;
47943 PyObject * obj0 = 0 ;
47944 PyObject * obj1 = 0 ;
47945 char * kwnames[] = {
47946 (char *) "box",(char *) "orient", NULL
47947 };
47948
47949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
47951 if (!SWIG_IsOK(res1)) {
47952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
47953 }
47954 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
47955 if (obj1) {
47956 ecode2 = SWIG_AsVal_int(obj1, &val2);
47957 if (!SWIG_IsOK(ecode2)) {
47958 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
47959 }
47960 arg2 = static_cast< int >(val2);
47961 }
47962 {
47963 PyThreadState* __tstate = wxPyBeginAllowThreads();
47964 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
47965 wxPyEndAllowThreads(__tstate);
47966 if (PyErr_Occurred()) SWIG_fail;
47967 }
47968 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
47969 return resultobj;
47970 fail:
47971 return NULL;
47972 }
47973
47974
47975 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47976 PyObject *resultobj = 0;
47977 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
47978 wxStaticBox *result = 0 ;
47979 void *argp1 = 0 ;
47980 int res1 = 0 ;
47981 PyObject *swig_obj[1] ;
47982
47983 if (!args) SWIG_fail;
47984 swig_obj[0] = args;
47985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
47986 if (!SWIG_IsOK(res1)) {
47987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
47988 }
47989 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
47990 {
47991 PyThreadState* __tstate = wxPyBeginAllowThreads();
47992 result = (wxStaticBox *)(arg1)->GetStaticBox();
47993 wxPyEndAllowThreads(__tstate);
47994 if (PyErr_Occurred()) SWIG_fail;
47995 }
47996 {
47997 resultobj = wxPyMake_wxObject(result, (bool)0);
47998 }
47999 return resultobj;
48000 fail:
48001 return NULL;
48002 }
48003
48004
48005 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48006 PyObject *obj;
48007 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48008 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
48009 return SWIG_Py_Void();
48010 }
48011
48012 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48013 return SWIG_Python_InitShadowInstance(args);
48014 }
48015
48016 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48017 PyObject *resultobj = 0;
48018 int arg1 = (int) 1 ;
48019 int arg2 = (int) 0 ;
48020 int arg3 = (int) 0 ;
48021 int arg4 = (int) 0 ;
48022 wxGridSizer *result = 0 ;
48023 int val1 ;
48024 int ecode1 = 0 ;
48025 int val2 ;
48026 int ecode2 = 0 ;
48027 int val3 ;
48028 int ecode3 = 0 ;
48029 int val4 ;
48030 int ecode4 = 0 ;
48031 PyObject * obj0 = 0 ;
48032 PyObject * obj1 = 0 ;
48033 PyObject * obj2 = 0 ;
48034 PyObject * obj3 = 0 ;
48035 char * kwnames[] = {
48036 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
48037 };
48038
48039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48040 if (obj0) {
48041 ecode1 = SWIG_AsVal_int(obj0, &val1);
48042 if (!SWIG_IsOK(ecode1)) {
48043 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
48044 }
48045 arg1 = static_cast< int >(val1);
48046 }
48047 if (obj1) {
48048 ecode2 = SWIG_AsVal_int(obj1, &val2);
48049 if (!SWIG_IsOK(ecode2)) {
48050 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
48051 }
48052 arg2 = static_cast< int >(val2);
48053 }
48054 if (obj2) {
48055 ecode3 = SWIG_AsVal_int(obj2, &val3);
48056 if (!SWIG_IsOK(ecode3)) {
48057 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
48058 }
48059 arg3 = static_cast< int >(val3);
48060 }
48061 if (obj3) {
48062 ecode4 = SWIG_AsVal_int(obj3, &val4);
48063 if (!SWIG_IsOK(ecode4)) {
48064 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
48065 }
48066 arg4 = static_cast< int >(val4);
48067 }
48068 {
48069 PyThreadState* __tstate = wxPyBeginAllowThreads();
48070 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
48071 wxPyEndAllowThreads(__tstate);
48072 if (PyErr_Occurred()) SWIG_fail;
48073 }
48074 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
48075 return resultobj;
48076 fail:
48077 return NULL;
48078 }
48079
48080
48081 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48082 PyObject *resultobj = 0;
48083 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48084 int arg2 ;
48085 void *argp1 = 0 ;
48086 int res1 = 0 ;
48087 int val2 ;
48088 int ecode2 = 0 ;
48089 PyObject * obj0 = 0 ;
48090 PyObject * obj1 = 0 ;
48091 char * kwnames[] = {
48092 (char *) "self",(char *) "cols", NULL
48093 };
48094
48095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
48096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48097 if (!SWIG_IsOK(res1)) {
48098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48099 }
48100 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48101 ecode2 = SWIG_AsVal_int(obj1, &val2);
48102 if (!SWIG_IsOK(ecode2)) {
48103 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
48104 }
48105 arg2 = static_cast< int >(val2);
48106 {
48107 PyThreadState* __tstate = wxPyBeginAllowThreads();
48108 (arg1)->SetCols(arg2);
48109 wxPyEndAllowThreads(__tstate);
48110 if (PyErr_Occurred()) SWIG_fail;
48111 }
48112 resultobj = SWIG_Py_Void();
48113 return resultobj;
48114 fail:
48115 return NULL;
48116 }
48117
48118
48119 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48120 PyObject *resultobj = 0;
48121 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48122 int arg2 ;
48123 void *argp1 = 0 ;
48124 int res1 = 0 ;
48125 int val2 ;
48126 int ecode2 = 0 ;
48127 PyObject * obj0 = 0 ;
48128 PyObject * obj1 = 0 ;
48129 char * kwnames[] = {
48130 (char *) "self",(char *) "rows", NULL
48131 };
48132
48133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
48134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48135 if (!SWIG_IsOK(res1)) {
48136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48137 }
48138 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48139 ecode2 = SWIG_AsVal_int(obj1, &val2);
48140 if (!SWIG_IsOK(ecode2)) {
48141 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
48142 }
48143 arg2 = static_cast< int >(val2);
48144 {
48145 PyThreadState* __tstate = wxPyBeginAllowThreads();
48146 (arg1)->SetRows(arg2);
48147 wxPyEndAllowThreads(__tstate);
48148 if (PyErr_Occurred()) SWIG_fail;
48149 }
48150 resultobj = SWIG_Py_Void();
48151 return resultobj;
48152 fail:
48153 return NULL;
48154 }
48155
48156
48157 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48158 PyObject *resultobj = 0;
48159 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48160 int arg2 ;
48161 void *argp1 = 0 ;
48162 int res1 = 0 ;
48163 int val2 ;
48164 int ecode2 = 0 ;
48165 PyObject * obj0 = 0 ;
48166 PyObject * obj1 = 0 ;
48167 char * kwnames[] = {
48168 (char *) "self",(char *) "gap", NULL
48169 };
48170
48171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
48172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48173 if (!SWIG_IsOK(res1)) {
48174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48175 }
48176 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48177 ecode2 = SWIG_AsVal_int(obj1, &val2);
48178 if (!SWIG_IsOK(ecode2)) {
48179 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
48180 }
48181 arg2 = static_cast< int >(val2);
48182 {
48183 PyThreadState* __tstate = wxPyBeginAllowThreads();
48184 (arg1)->SetVGap(arg2);
48185 wxPyEndAllowThreads(__tstate);
48186 if (PyErr_Occurred()) SWIG_fail;
48187 }
48188 resultobj = SWIG_Py_Void();
48189 return resultobj;
48190 fail:
48191 return NULL;
48192 }
48193
48194
48195 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48196 PyObject *resultobj = 0;
48197 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48198 int arg2 ;
48199 void *argp1 = 0 ;
48200 int res1 = 0 ;
48201 int val2 ;
48202 int ecode2 = 0 ;
48203 PyObject * obj0 = 0 ;
48204 PyObject * obj1 = 0 ;
48205 char * kwnames[] = {
48206 (char *) "self",(char *) "gap", NULL
48207 };
48208
48209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
48210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48211 if (!SWIG_IsOK(res1)) {
48212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48213 }
48214 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48215 ecode2 = SWIG_AsVal_int(obj1, &val2);
48216 if (!SWIG_IsOK(ecode2)) {
48217 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
48218 }
48219 arg2 = static_cast< int >(val2);
48220 {
48221 PyThreadState* __tstate = wxPyBeginAllowThreads();
48222 (arg1)->SetHGap(arg2);
48223 wxPyEndAllowThreads(__tstate);
48224 if (PyErr_Occurred()) SWIG_fail;
48225 }
48226 resultobj = SWIG_Py_Void();
48227 return resultobj;
48228 fail:
48229 return NULL;
48230 }
48231
48232
48233 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48234 PyObject *resultobj = 0;
48235 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48236 int result;
48237 void *argp1 = 0 ;
48238 int res1 = 0 ;
48239 PyObject *swig_obj[1] ;
48240
48241 if (!args) SWIG_fail;
48242 swig_obj[0] = args;
48243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48244 if (!SWIG_IsOK(res1)) {
48245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48246 }
48247 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48248 {
48249 PyThreadState* __tstate = wxPyBeginAllowThreads();
48250 result = (int)(arg1)->GetCols();
48251 wxPyEndAllowThreads(__tstate);
48252 if (PyErr_Occurred()) SWIG_fail;
48253 }
48254 resultobj = SWIG_From_int(static_cast< int >(result));
48255 return resultobj;
48256 fail:
48257 return NULL;
48258 }
48259
48260
48261 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48262 PyObject *resultobj = 0;
48263 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48264 int result;
48265 void *argp1 = 0 ;
48266 int res1 = 0 ;
48267 PyObject *swig_obj[1] ;
48268
48269 if (!args) SWIG_fail;
48270 swig_obj[0] = args;
48271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48272 if (!SWIG_IsOK(res1)) {
48273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48274 }
48275 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48276 {
48277 PyThreadState* __tstate = wxPyBeginAllowThreads();
48278 result = (int)(arg1)->GetRows();
48279 wxPyEndAllowThreads(__tstate);
48280 if (PyErr_Occurred()) SWIG_fail;
48281 }
48282 resultobj = SWIG_From_int(static_cast< int >(result));
48283 return resultobj;
48284 fail:
48285 return NULL;
48286 }
48287
48288
48289 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48290 PyObject *resultobj = 0;
48291 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48292 int result;
48293 void *argp1 = 0 ;
48294 int res1 = 0 ;
48295 PyObject *swig_obj[1] ;
48296
48297 if (!args) SWIG_fail;
48298 swig_obj[0] = args;
48299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48300 if (!SWIG_IsOK(res1)) {
48301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48302 }
48303 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48304 {
48305 PyThreadState* __tstate = wxPyBeginAllowThreads();
48306 result = (int)(arg1)->GetVGap();
48307 wxPyEndAllowThreads(__tstate);
48308 if (PyErr_Occurred()) SWIG_fail;
48309 }
48310 resultobj = SWIG_From_int(static_cast< int >(result));
48311 return resultobj;
48312 fail:
48313 return NULL;
48314 }
48315
48316
48317 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48318 PyObject *resultobj = 0;
48319 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48320 int result;
48321 void *argp1 = 0 ;
48322 int res1 = 0 ;
48323 PyObject *swig_obj[1] ;
48324
48325 if (!args) SWIG_fail;
48326 swig_obj[0] = args;
48327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48328 if (!SWIG_IsOK(res1)) {
48329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48330 }
48331 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48332 {
48333 PyThreadState* __tstate = wxPyBeginAllowThreads();
48334 result = (int)(arg1)->GetHGap();
48335 wxPyEndAllowThreads(__tstate);
48336 if (PyErr_Occurred()) SWIG_fail;
48337 }
48338 resultobj = SWIG_From_int(static_cast< int >(result));
48339 return resultobj;
48340 fail:
48341 return NULL;
48342 }
48343
48344
48345 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48346 PyObject *obj;
48347 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48348 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
48349 return SWIG_Py_Void();
48350 }
48351
48352 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48353 return SWIG_Python_InitShadowInstance(args);
48354 }
48355
48356 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48357 PyObject *resultobj = 0;
48358 int arg1 = (int) 1 ;
48359 int arg2 = (int) 0 ;
48360 int arg3 = (int) 0 ;
48361 int arg4 = (int) 0 ;
48362 wxFlexGridSizer *result = 0 ;
48363 int val1 ;
48364 int ecode1 = 0 ;
48365 int val2 ;
48366 int ecode2 = 0 ;
48367 int val3 ;
48368 int ecode3 = 0 ;
48369 int val4 ;
48370 int ecode4 = 0 ;
48371 PyObject * obj0 = 0 ;
48372 PyObject * obj1 = 0 ;
48373 PyObject * obj2 = 0 ;
48374 PyObject * obj3 = 0 ;
48375 char * kwnames[] = {
48376 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
48377 };
48378
48379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48380 if (obj0) {
48381 ecode1 = SWIG_AsVal_int(obj0, &val1);
48382 if (!SWIG_IsOK(ecode1)) {
48383 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
48384 }
48385 arg1 = static_cast< int >(val1);
48386 }
48387 if (obj1) {
48388 ecode2 = SWIG_AsVal_int(obj1, &val2);
48389 if (!SWIG_IsOK(ecode2)) {
48390 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
48391 }
48392 arg2 = static_cast< int >(val2);
48393 }
48394 if (obj2) {
48395 ecode3 = SWIG_AsVal_int(obj2, &val3);
48396 if (!SWIG_IsOK(ecode3)) {
48397 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
48398 }
48399 arg3 = static_cast< int >(val3);
48400 }
48401 if (obj3) {
48402 ecode4 = SWIG_AsVal_int(obj3, &val4);
48403 if (!SWIG_IsOK(ecode4)) {
48404 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
48405 }
48406 arg4 = static_cast< int >(val4);
48407 }
48408 {
48409 PyThreadState* __tstate = wxPyBeginAllowThreads();
48410 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
48411 wxPyEndAllowThreads(__tstate);
48412 if (PyErr_Occurred()) SWIG_fail;
48413 }
48414 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
48415 return resultobj;
48416 fail:
48417 return NULL;
48418 }
48419
48420
48421 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48422 PyObject *resultobj = 0;
48423 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48424 size_t arg2 ;
48425 int arg3 = (int) 0 ;
48426 void *argp1 = 0 ;
48427 int res1 = 0 ;
48428 size_t val2 ;
48429 int ecode2 = 0 ;
48430 int val3 ;
48431 int ecode3 = 0 ;
48432 PyObject * obj0 = 0 ;
48433 PyObject * obj1 = 0 ;
48434 PyObject * obj2 = 0 ;
48435 char * kwnames[] = {
48436 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48437 };
48438
48439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48441 if (!SWIG_IsOK(res1)) {
48442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48443 }
48444 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48445 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48446 if (!SWIG_IsOK(ecode2)) {
48447 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
48448 }
48449 arg2 = static_cast< size_t >(val2);
48450 if (obj2) {
48451 ecode3 = SWIG_AsVal_int(obj2, &val3);
48452 if (!SWIG_IsOK(ecode3)) {
48453 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
48454 }
48455 arg3 = static_cast< int >(val3);
48456 }
48457 {
48458 PyThreadState* __tstate = wxPyBeginAllowThreads();
48459 (arg1)->AddGrowableRow(arg2,arg3);
48460 wxPyEndAllowThreads(__tstate);
48461 if (PyErr_Occurred()) SWIG_fail;
48462 }
48463 resultobj = SWIG_Py_Void();
48464 return resultobj;
48465 fail:
48466 return NULL;
48467 }
48468
48469
48470 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48471 PyObject *resultobj = 0;
48472 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48473 size_t arg2 ;
48474 void *argp1 = 0 ;
48475 int res1 = 0 ;
48476 size_t val2 ;
48477 int ecode2 = 0 ;
48478 PyObject * obj0 = 0 ;
48479 PyObject * obj1 = 0 ;
48480 char * kwnames[] = {
48481 (char *) "self",(char *) "idx", NULL
48482 };
48483
48484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
48485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48486 if (!SWIG_IsOK(res1)) {
48487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48488 }
48489 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48490 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48491 if (!SWIG_IsOK(ecode2)) {
48492 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
48493 }
48494 arg2 = static_cast< size_t >(val2);
48495 {
48496 PyThreadState* __tstate = wxPyBeginAllowThreads();
48497 (arg1)->RemoveGrowableRow(arg2);
48498 wxPyEndAllowThreads(__tstate);
48499 if (PyErr_Occurred()) SWIG_fail;
48500 }
48501 resultobj = SWIG_Py_Void();
48502 return resultobj;
48503 fail:
48504 return NULL;
48505 }
48506
48507
48508 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48509 PyObject *resultobj = 0;
48510 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48511 size_t arg2 ;
48512 int arg3 = (int) 0 ;
48513 void *argp1 = 0 ;
48514 int res1 = 0 ;
48515 size_t val2 ;
48516 int ecode2 = 0 ;
48517 int val3 ;
48518 int ecode3 = 0 ;
48519 PyObject * obj0 = 0 ;
48520 PyObject * obj1 = 0 ;
48521 PyObject * obj2 = 0 ;
48522 char * kwnames[] = {
48523 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48524 };
48525
48526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48528 if (!SWIG_IsOK(res1)) {
48529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48530 }
48531 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48532 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48533 if (!SWIG_IsOK(ecode2)) {
48534 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48535 }
48536 arg2 = static_cast< size_t >(val2);
48537 if (obj2) {
48538 ecode3 = SWIG_AsVal_int(obj2, &val3);
48539 if (!SWIG_IsOK(ecode3)) {
48540 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
48541 }
48542 arg3 = static_cast< int >(val3);
48543 }
48544 {
48545 PyThreadState* __tstate = wxPyBeginAllowThreads();
48546 (arg1)->AddGrowableCol(arg2,arg3);
48547 wxPyEndAllowThreads(__tstate);
48548 if (PyErr_Occurred()) SWIG_fail;
48549 }
48550 resultobj = SWIG_Py_Void();
48551 return resultobj;
48552 fail:
48553 return NULL;
48554 }
48555
48556
48557 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48558 PyObject *resultobj = 0;
48559 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48560 size_t arg2 ;
48561 void *argp1 = 0 ;
48562 int res1 = 0 ;
48563 size_t val2 ;
48564 int ecode2 = 0 ;
48565 PyObject * obj0 = 0 ;
48566 PyObject * obj1 = 0 ;
48567 char * kwnames[] = {
48568 (char *) "self",(char *) "idx", NULL
48569 };
48570
48571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
48572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48573 if (!SWIG_IsOK(res1)) {
48574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48575 }
48576 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48577 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48578 if (!SWIG_IsOK(ecode2)) {
48579 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48580 }
48581 arg2 = static_cast< size_t >(val2);
48582 {
48583 PyThreadState* __tstate = wxPyBeginAllowThreads();
48584 (arg1)->RemoveGrowableCol(arg2);
48585 wxPyEndAllowThreads(__tstate);
48586 if (PyErr_Occurred()) SWIG_fail;
48587 }
48588 resultobj = SWIG_Py_Void();
48589 return resultobj;
48590 fail:
48591 return NULL;
48592 }
48593
48594
48595 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48596 PyObject *resultobj = 0;
48597 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48598 int arg2 ;
48599 void *argp1 = 0 ;
48600 int res1 = 0 ;
48601 int val2 ;
48602 int ecode2 = 0 ;
48603 PyObject * obj0 = 0 ;
48604 PyObject * obj1 = 0 ;
48605 char * kwnames[] = {
48606 (char *) "self",(char *) "direction", NULL
48607 };
48608
48609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
48610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48611 if (!SWIG_IsOK(res1)) {
48612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48613 }
48614 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48615 ecode2 = SWIG_AsVal_int(obj1, &val2);
48616 if (!SWIG_IsOK(ecode2)) {
48617 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
48618 }
48619 arg2 = static_cast< int >(val2);
48620 {
48621 PyThreadState* __tstate = wxPyBeginAllowThreads();
48622 (arg1)->SetFlexibleDirection(arg2);
48623 wxPyEndAllowThreads(__tstate);
48624 if (PyErr_Occurred()) SWIG_fail;
48625 }
48626 resultobj = SWIG_Py_Void();
48627 return resultobj;
48628 fail:
48629 return NULL;
48630 }
48631
48632
48633 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48634 PyObject *resultobj = 0;
48635 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48636 int result;
48637 void *argp1 = 0 ;
48638 int res1 = 0 ;
48639 PyObject *swig_obj[1] ;
48640
48641 if (!args) SWIG_fail;
48642 swig_obj[0] = args;
48643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48644 if (!SWIG_IsOK(res1)) {
48645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48646 }
48647 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48648 {
48649 PyThreadState* __tstate = wxPyBeginAllowThreads();
48650 result = (int)(arg1)->GetFlexibleDirection();
48651 wxPyEndAllowThreads(__tstate);
48652 if (PyErr_Occurred()) SWIG_fail;
48653 }
48654 resultobj = SWIG_From_int(static_cast< int >(result));
48655 return resultobj;
48656 fail:
48657 return NULL;
48658 }
48659
48660
48661 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48662 PyObject *resultobj = 0;
48663 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48664 wxFlexSizerGrowMode arg2 ;
48665 void *argp1 = 0 ;
48666 int res1 = 0 ;
48667 int val2 ;
48668 int ecode2 = 0 ;
48669 PyObject * obj0 = 0 ;
48670 PyObject * obj1 = 0 ;
48671 char * kwnames[] = {
48672 (char *) "self",(char *) "mode", NULL
48673 };
48674
48675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
48676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48677 if (!SWIG_IsOK(res1)) {
48678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48679 }
48680 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48681 ecode2 = SWIG_AsVal_int(obj1, &val2);
48682 if (!SWIG_IsOK(ecode2)) {
48683 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
48684 }
48685 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
48686 {
48687 PyThreadState* __tstate = wxPyBeginAllowThreads();
48688 (arg1)->SetNonFlexibleGrowMode(arg2);
48689 wxPyEndAllowThreads(__tstate);
48690 if (PyErr_Occurred()) SWIG_fail;
48691 }
48692 resultobj = SWIG_Py_Void();
48693 return resultobj;
48694 fail:
48695 return NULL;
48696 }
48697
48698
48699 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48700 PyObject *resultobj = 0;
48701 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48702 wxFlexSizerGrowMode result;
48703 void *argp1 = 0 ;
48704 int res1 = 0 ;
48705 PyObject *swig_obj[1] ;
48706
48707 if (!args) SWIG_fail;
48708 swig_obj[0] = args;
48709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48710 if (!SWIG_IsOK(res1)) {
48711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48712 }
48713 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48714 {
48715 PyThreadState* __tstate = wxPyBeginAllowThreads();
48716 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
48717 wxPyEndAllowThreads(__tstate);
48718 if (PyErr_Occurred()) SWIG_fail;
48719 }
48720 resultobj = SWIG_From_int(static_cast< int >(result));
48721 return resultobj;
48722 fail:
48723 return NULL;
48724 }
48725
48726
48727 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48728 PyObject *resultobj = 0;
48729 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48730 wxArrayInt *result = 0 ;
48731 void *argp1 = 0 ;
48732 int res1 = 0 ;
48733 PyObject *swig_obj[1] ;
48734
48735 if (!args) SWIG_fail;
48736 swig_obj[0] = args;
48737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48738 if (!SWIG_IsOK(res1)) {
48739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48740 }
48741 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48742 {
48743 PyThreadState* __tstate = wxPyBeginAllowThreads();
48744 {
48745 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
48746 result = (wxArrayInt *) &_result_ref;
48747 }
48748 wxPyEndAllowThreads(__tstate);
48749 if (PyErr_Occurred()) SWIG_fail;
48750 }
48751 {
48752 resultobj = PyList_New(0);
48753 size_t idx;
48754 for (idx = 0; idx < result->GetCount(); idx += 1) {
48755 PyObject* val = PyInt_FromLong( result->Item(idx) );
48756 PyList_Append(resultobj, val);
48757 Py_DECREF(val);
48758 }
48759 }
48760 return resultobj;
48761 fail:
48762 return NULL;
48763 }
48764
48765
48766 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48767 PyObject *resultobj = 0;
48768 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48769 wxArrayInt *result = 0 ;
48770 void *argp1 = 0 ;
48771 int res1 = 0 ;
48772 PyObject *swig_obj[1] ;
48773
48774 if (!args) SWIG_fail;
48775 swig_obj[0] = args;
48776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48777 if (!SWIG_IsOK(res1)) {
48778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48779 }
48780 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48781 {
48782 PyThreadState* __tstate = wxPyBeginAllowThreads();
48783 {
48784 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
48785 result = (wxArrayInt *) &_result_ref;
48786 }
48787 wxPyEndAllowThreads(__tstate);
48788 if (PyErr_Occurred()) SWIG_fail;
48789 }
48790 {
48791 resultobj = PyList_New(0);
48792 size_t idx;
48793 for (idx = 0; idx < result->GetCount(); idx += 1) {
48794 PyObject* val = PyInt_FromLong( result->Item(idx) );
48795 PyList_Append(resultobj, val);
48796 Py_DECREF(val);
48797 }
48798 }
48799 return resultobj;
48800 fail:
48801 return NULL;
48802 }
48803
48804
48805 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48806 PyObject *obj;
48807 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48808 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
48809 return SWIG_Py_Void();
48810 }
48811
48812 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48813 return SWIG_Python_InitShadowInstance(args);
48814 }
48815
48816 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48817 PyObject *resultobj = 0;
48818 wxStdDialogButtonSizer *result = 0 ;
48819
48820 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
48821 {
48822 PyThreadState* __tstate = wxPyBeginAllowThreads();
48823 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
48824 wxPyEndAllowThreads(__tstate);
48825 if (PyErr_Occurred()) SWIG_fail;
48826 }
48827 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
48828 return resultobj;
48829 fail:
48830 return NULL;
48831 }
48832
48833
48834 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48835 PyObject *resultobj = 0;
48836 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48837 wxButton *arg2 = (wxButton *) 0 ;
48838 void *argp1 = 0 ;
48839 int res1 = 0 ;
48840 void *argp2 = 0 ;
48841 int res2 = 0 ;
48842 PyObject * obj0 = 0 ;
48843 PyObject * obj1 = 0 ;
48844 char * kwnames[] = {
48845 (char *) "self",(char *) "button", NULL
48846 };
48847
48848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
48849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48850 if (!SWIG_IsOK(res1)) {
48851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48852 }
48853 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48854 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48855 if (!SWIG_IsOK(res2)) {
48856 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
48857 }
48858 arg2 = reinterpret_cast< wxButton * >(argp2);
48859 {
48860 PyThreadState* __tstate = wxPyBeginAllowThreads();
48861 (arg1)->AddButton(arg2);
48862 wxPyEndAllowThreads(__tstate);
48863 if (PyErr_Occurred()) SWIG_fail;
48864 }
48865 resultobj = SWIG_Py_Void();
48866 return resultobj;
48867 fail:
48868 return NULL;
48869 }
48870
48871
48872 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48873 PyObject *resultobj = 0;
48874 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48875 void *argp1 = 0 ;
48876 int res1 = 0 ;
48877 PyObject *swig_obj[1] ;
48878
48879 if (!args) SWIG_fail;
48880 swig_obj[0] = args;
48881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48882 if (!SWIG_IsOK(res1)) {
48883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48884 }
48885 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48886 {
48887 PyThreadState* __tstate = wxPyBeginAllowThreads();
48888 (arg1)->Realize();
48889 wxPyEndAllowThreads(__tstate);
48890 if (PyErr_Occurred()) SWIG_fail;
48891 }
48892 resultobj = SWIG_Py_Void();
48893 return resultobj;
48894 fail:
48895 return NULL;
48896 }
48897
48898
48899 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48900 PyObject *resultobj = 0;
48901 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48902 wxButton *arg2 = (wxButton *) 0 ;
48903 void *argp1 = 0 ;
48904 int res1 = 0 ;
48905 void *argp2 = 0 ;
48906 int res2 = 0 ;
48907 PyObject * obj0 = 0 ;
48908 PyObject * obj1 = 0 ;
48909 char * kwnames[] = {
48910 (char *) "self",(char *) "button", NULL
48911 };
48912
48913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48915 if (!SWIG_IsOK(res1)) {
48916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48917 }
48918 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48919 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48920 if (!SWIG_IsOK(res2)) {
48921 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48922 }
48923 arg2 = reinterpret_cast< wxButton * >(argp2);
48924 {
48925 PyThreadState* __tstate = wxPyBeginAllowThreads();
48926 (arg1)->SetAffirmativeButton(arg2);
48927 wxPyEndAllowThreads(__tstate);
48928 if (PyErr_Occurred()) SWIG_fail;
48929 }
48930 resultobj = SWIG_Py_Void();
48931 return resultobj;
48932 fail:
48933 return NULL;
48934 }
48935
48936
48937 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48938 PyObject *resultobj = 0;
48939 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48940 wxButton *arg2 = (wxButton *) 0 ;
48941 void *argp1 = 0 ;
48942 int res1 = 0 ;
48943 void *argp2 = 0 ;
48944 int res2 = 0 ;
48945 PyObject * obj0 = 0 ;
48946 PyObject * obj1 = 0 ;
48947 char * kwnames[] = {
48948 (char *) "self",(char *) "button", NULL
48949 };
48950
48951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48952 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48953 if (!SWIG_IsOK(res1)) {
48954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48955 }
48956 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48957 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48958 if (!SWIG_IsOK(res2)) {
48959 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48960 }
48961 arg2 = reinterpret_cast< wxButton * >(argp2);
48962 {
48963 PyThreadState* __tstate = wxPyBeginAllowThreads();
48964 (arg1)->SetNegativeButton(arg2);
48965 wxPyEndAllowThreads(__tstate);
48966 if (PyErr_Occurred()) SWIG_fail;
48967 }
48968 resultobj = SWIG_Py_Void();
48969 return resultobj;
48970 fail:
48971 return NULL;
48972 }
48973
48974
48975 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48976 PyObject *resultobj = 0;
48977 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48978 wxButton *arg2 = (wxButton *) 0 ;
48979 void *argp1 = 0 ;
48980 int res1 = 0 ;
48981 void *argp2 = 0 ;
48982 int res2 = 0 ;
48983 PyObject * obj0 = 0 ;
48984 PyObject * obj1 = 0 ;
48985 char * kwnames[] = {
48986 (char *) "self",(char *) "button", NULL
48987 };
48988
48989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
48990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48991 if (!SWIG_IsOK(res1)) {
48992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48993 }
48994 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48995 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48996 if (!SWIG_IsOK(res2)) {
48997 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
48998 }
48999 arg2 = reinterpret_cast< wxButton * >(argp2);
49000 {
49001 PyThreadState* __tstate = wxPyBeginAllowThreads();
49002 (arg1)->SetCancelButton(arg2);
49003 wxPyEndAllowThreads(__tstate);
49004 if (PyErr_Occurred()) SWIG_fail;
49005 }
49006 resultobj = SWIG_Py_Void();
49007 return resultobj;
49008 fail:
49009 return NULL;
49010 }
49011
49012
49013 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49014 PyObject *resultobj = 0;
49015 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49016 wxButton *result = 0 ;
49017 void *argp1 = 0 ;
49018 int res1 = 0 ;
49019 PyObject *swig_obj[1] ;
49020
49021 if (!args) SWIG_fail;
49022 swig_obj[0] = args;
49023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49024 if (!SWIG_IsOK(res1)) {
49025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49026 }
49027 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49028 {
49029 PyThreadState* __tstate = wxPyBeginAllowThreads();
49030 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
49031 wxPyEndAllowThreads(__tstate);
49032 if (PyErr_Occurred()) SWIG_fail;
49033 }
49034 {
49035 resultobj = wxPyMake_wxObject(result, (bool)0);
49036 }
49037 return resultobj;
49038 fail:
49039 return NULL;
49040 }
49041
49042
49043 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49044 PyObject *resultobj = 0;
49045 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49046 wxButton *result = 0 ;
49047 void *argp1 = 0 ;
49048 int res1 = 0 ;
49049 PyObject *swig_obj[1] ;
49050
49051 if (!args) SWIG_fail;
49052 swig_obj[0] = args;
49053 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49054 if (!SWIG_IsOK(res1)) {
49055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49056 }
49057 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49058 {
49059 PyThreadState* __tstate = wxPyBeginAllowThreads();
49060 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
49061 wxPyEndAllowThreads(__tstate);
49062 if (PyErr_Occurred()) SWIG_fail;
49063 }
49064 {
49065 resultobj = wxPyMake_wxObject(result, (bool)0);
49066 }
49067 return resultobj;
49068 fail:
49069 return NULL;
49070 }
49071
49072
49073 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49074 PyObject *resultobj = 0;
49075 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49076 wxButton *result = 0 ;
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_wxStdDialogButtonSizer, 0 | 0 );
49084 if (!SWIG_IsOK(res1)) {
49085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49086 }
49087 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49088 {
49089 PyThreadState* __tstate = wxPyBeginAllowThreads();
49090 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
49091 wxPyEndAllowThreads(__tstate);
49092 if (PyErr_Occurred()) SWIG_fail;
49093 }
49094 {
49095 resultobj = wxPyMake_wxObject(result, (bool)0);
49096 }
49097 return resultobj;
49098 fail:
49099 return NULL;
49100 }
49101
49102
49103 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49104 PyObject *resultobj = 0;
49105 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49106 wxButton *result = 0 ;
49107 void *argp1 = 0 ;
49108 int res1 = 0 ;
49109 PyObject *swig_obj[1] ;
49110
49111 if (!args) SWIG_fail;
49112 swig_obj[0] = args;
49113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49114 if (!SWIG_IsOK(res1)) {
49115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49116 }
49117 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49118 {
49119 PyThreadState* __tstate = wxPyBeginAllowThreads();
49120 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
49121 wxPyEndAllowThreads(__tstate);
49122 if (PyErr_Occurred()) SWIG_fail;
49123 }
49124 {
49125 resultobj = wxPyMake_wxObject(result, (bool)0);
49126 }
49127 return resultobj;
49128 fail:
49129 return NULL;
49130 }
49131
49132
49133 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49134 PyObject *resultobj = 0;
49135 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49136 wxButton *result = 0 ;
49137 void *argp1 = 0 ;
49138 int res1 = 0 ;
49139 PyObject *swig_obj[1] ;
49140
49141 if (!args) SWIG_fail;
49142 swig_obj[0] = args;
49143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49144 if (!SWIG_IsOK(res1)) {
49145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49146 }
49147 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49148 {
49149 PyThreadState* __tstate = wxPyBeginAllowThreads();
49150 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
49151 wxPyEndAllowThreads(__tstate);
49152 if (PyErr_Occurred()) SWIG_fail;
49153 }
49154 {
49155 resultobj = wxPyMake_wxObject(result, (bool)0);
49156 }
49157 return resultobj;
49158 fail:
49159 return NULL;
49160 }
49161
49162
49163 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49164 PyObject *obj;
49165 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49166 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
49167 return SWIG_Py_Void();
49168 }
49169
49170 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49171 return SWIG_Python_InitShadowInstance(args);
49172 }
49173
49174 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49175 PyObject *resultobj = 0;
49176 int arg1 = (int) 0 ;
49177 int arg2 = (int) 0 ;
49178 wxGBPosition *result = 0 ;
49179 int val1 ;
49180 int ecode1 = 0 ;
49181 int val2 ;
49182 int ecode2 = 0 ;
49183 PyObject * obj0 = 0 ;
49184 PyObject * obj1 = 0 ;
49185 char * kwnames[] = {
49186 (char *) "row",(char *) "col", NULL
49187 };
49188
49189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
49190 if (obj0) {
49191 ecode1 = SWIG_AsVal_int(obj0, &val1);
49192 if (!SWIG_IsOK(ecode1)) {
49193 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
49194 }
49195 arg1 = static_cast< int >(val1);
49196 }
49197 if (obj1) {
49198 ecode2 = SWIG_AsVal_int(obj1, &val2);
49199 if (!SWIG_IsOK(ecode2)) {
49200 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
49201 }
49202 arg2 = static_cast< int >(val2);
49203 }
49204 {
49205 PyThreadState* __tstate = wxPyBeginAllowThreads();
49206 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
49207 wxPyEndAllowThreads(__tstate);
49208 if (PyErr_Occurred()) SWIG_fail;
49209 }
49210 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
49211 return resultobj;
49212 fail:
49213 return NULL;
49214 }
49215
49216
49217 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49218 PyObject *resultobj = 0;
49219 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49220 void *argp1 = 0 ;
49221 int res1 = 0 ;
49222 PyObject *swig_obj[1] ;
49223
49224 if (!args) SWIG_fail;
49225 swig_obj[0] = args;
49226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
49227 if (!SWIG_IsOK(res1)) {
49228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49229 }
49230 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49231 {
49232 PyThreadState* __tstate = wxPyBeginAllowThreads();
49233 delete arg1;
49234
49235 wxPyEndAllowThreads(__tstate);
49236 if (PyErr_Occurred()) SWIG_fail;
49237 }
49238 resultobj = SWIG_Py_Void();
49239 return resultobj;
49240 fail:
49241 return NULL;
49242 }
49243
49244
49245 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49246 PyObject *resultobj = 0;
49247 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49248 int result;
49249 void *argp1 = 0 ;
49250 int res1 = 0 ;
49251 PyObject *swig_obj[1] ;
49252
49253 if (!args) SWIG_fail;
49254 swig_obj[0] = args;
49255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49256 if (!SWIG_IsOK(res1)) {
49257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
49258 }
49259 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49260 {
49261 PyThreadState* __tstate = wxPyBeginAllowThreads();
49262 result = (int)((wxGBPosition const *)arg1)->GetRow();
49263 wxPyEndAllowThreads(__tstate);
49264 if (PyErr_Occurred()) SWIG_fail;
49265 }
49266 resultobj = SWIG_From_int(static_cast< int >(result));
49267 return resultobj;
49268 fail:
49269 return NULL;
49270 }
49271
49272
49273 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49274 PyObject *resultobj = 0;
49275 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49276 int result;
49277 void *argp1 = 0 ;
49278 int res1 = 0 ;
49279 PyObject *swig_obj[1] ;
49280
49281 if (!args) SWIG_fail;
49282 swig_obj[0] = args;
49283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49284 if (!SWIG_IsOK(res1)) {
49285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
49286 }
49287 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49288 {
49289 PyThreadState* __tstate = wxPyBeginAllowThreads();
49290 result = (int)((wxGBPosition const *)arg1)->GetCol();
49291 wxPyEndAllowThreads(__tstate);
49292 if (PyErr_Occurred()) SWIG_fail;
49293 }
49294 resultobj = SWIG_From_int(static_cast< int >(result));
49295 return resultobj;
49296 fail:
49297 return NULL;
49298 }
49299
49300
49301 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49302 PyObject *resultobj = 0;
49303 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49304 int arg2 ;
49305 void *argp1 = 0 ;
49306 int res1 = 0 ;
49307 int val2 ;
49308 int ecode2 = 0 ;
49309 PyObject * obj0 = 0 ;
49310 PyObject * obj1 = 0 ;
49311 char * kwnames[] = {
49312 (char *) "self",(char *) "row", NULL
49313 };
49314
49315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
49316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49317 if (!SWIG_IsOK(res1)) {
49318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49319 }
49320 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49321 ecode2 = SWIG_AsVal_int(obj1, &val2);
49322 if (!SWIG_IsOK(ecode2)) {
49323 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
49324 }
49325 arg2 = static_cast< int >(val2);
49326 {
49327 PyThreadState* __tstate = wxPyBeginAllowThreads();
49328 (arg1)->SetRow(arg2);
49329 wxPyEndAllowThreads(__tstate);
49330 if (PyErr_Occurred()) SWIG_fail;
49331 }
49332 resultobj = SWIG_Py_Void();
49333 return resultobj;
49334 fail:
49335 return NULL;
49336 }
49337
49338
49339 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49340 PyObject *resultobj = 0;
49341 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49342 int arg2 ;
49343 void *argp1 = 0 ;
49344 int res1 = 0 ;
49345 int val2 ;
49346 int ecode2 = 0 ;
49347 PyObject * obj0 = 0 ;
49348 PyObject * obj1 = 0 ;
49349 char * kwnames[] = {
49350 (char *) "self",(char *) "col", NULL
49351 };
49352
49353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
49354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49355 if (!SWIG_IsOK(res1)) {
49356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49357 }
49358 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49359 ecode2 = SWIG_AsVal_int(obj1, &val2);
49360 if (!SWIG_IsOK(ecode2)) {
49361 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
49362 }
49363 arg2 = static_cast< int >(val2);
49364 {
49365 PyThreadState* __tstate = wxPyBeginAllowThreads();
49366 (arg1)->SetCol(arg2);
49367 wxPyEndAllowThreads(__tstate);
49368 if (PyErr_Occurred()) SWIG_fail;
49369 }
49370 resultobj = SWIG_Py_Void();
49371 return resultobj;
49372 fail:
49373 return NULL;
49374 }
49375
49376
49377 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49378 PyObject *resultobj = 0;
49379 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49380 PyObject *arg2 = (PyObject *) 0 ;
49381 bool result;
49382 void *argp1 = 0 ;
49383 int res1 = 0 ;
49384 PyObject * obj0 = 0 ;
49385 PyObject * obj1 = 0 ;
49386 char * kwnames[] = {
49387 (char *) "self",(char *) "other", NULL
49388 };
49389
49390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49392 if (!SWIG_IsOK(res1)) {
49393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49394 }
49395 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49396 arg2 = obj1;
49397 {
49398 result = (bool)wxGBPosition___eq__(arg1,arg2);
49399 if (PyErr_Occurred()) SWIG_fail;
49400 }
49401 {
49402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49403 }
49404 return resultobj;
49405 fail:
49406 return NULL;
49407 }
49408
49409
49410 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49411 PyObject *resultobj = 0;
49412 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49413 PyObject *arg2 = (PyObject *) 0 ;
49414 bool result;
49415 void *argp1 = 0 ;
49416 int res1 = 0 ;
49417 PyObject * obj0 = 0 ;
49418 PyObject * obj1 = 0 ;
49419 char * kwnames[] = {
49420 (char *) "self",(char *) "other", NULL
49421 };
49422
49423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49425 if (!SWIG_IsOK(res1)) {
49426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49427 }
49428 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49429 arg2 = obj1;
49430 {
49431 result = (bool)wxGBPosition___ne__(arg1,arg2);
49432 if (PyErr_Occurred()) SWIG_fail;
49433 }
49434 {
49435 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49436 }
49437 return resultobj;
49438 fail:
49439 return NULL;
49440 }
49441
49442
49443 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49444 PyObject *resultobj = 0;
49445 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49446 int arg2 = (int) 0 ;
49447 int arg3 = (int) 0 ;
49448 void *argp1 = 0 ;
49449 int res1 = 0 ;
49450 int val2 ;
49451 int ecode2 = 0 ;
49452 int val3 ;
49453 int ecode3 = 0 ;
49454 PyObject * obj0 = 0 ;
49455 PyObject * obj1 = 0 ;
49456 PyObject * obj2 = 0 ;
49457 char * kwnames[] = {
49458 (char *) "self",(char *) "row",(char *) "col", NULL
49459 };
49460
49461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49463 if (!SWIG_IsOK(res1)) {
49464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49465 }
49466 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49467 if (obj1) {
49468 ecode2 = SWIG_AsVal_int(obj1, &val2);
49469 if (!SWIG_IsOK(ecode2)) {
49470 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
49471 }
49472 arg2 = static_cast< int >(val2);
49473 }
49474 if (obj2) {
49475 ecode3 = SWIG_AsVal_int(obj2, &val3);
49476 if (!SWIG_IsOK(ecode3)) {
49477 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
49478 }
49479 arg3 = static_cast< int >(val3);
49480 }
49481 {
49482 PyThreadState* __tstate = wxPyBeginAllowThreads();
49483 wxGBPosition_Set(arg1,arg2,arg3);
49484 wxPyEndAllowThreads(__tstate);
49485 if (PyErr_Occurred()) SWIG_fail;
49486 }
49487 resultobj = SWIG_Py_Void();
49488 return resultobj;
49489 fail:
49490 return NULL;
49491 }
49492
49493
49494 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49495 PyObject *resultobj = 0;
49496 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49497 PyObject *result = 0 ;
49498 void *argp1 = 0 ;
49499 int res1 = 0 ;
49500 PyObject *swig_obj[1] ;
49501
49502 if (!args) SWIG_fail;
49503 swig_obj[0] = args;
49504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49505 if (!SWIG_IsOK(res1)) {
49506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49507 }
49508 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49509 {
49510 PyThreadState* __tstate = wxPyBeginAllowThreads();
49511 result = (PyObject *)wxGBPosition_Get(arg1);
49512 wxPyEndAllowThreads(__tstate);
49513 if (PyErr_Occurred()) SWIG_fail;
49514 }
49515 resultobj = result;
49516 return resultobj;
49517 fail:
49518 return NULL;
49519 }
49520
49521
49522 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49523 PyObject *obj;
49524 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49525 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
49526 return SWIG_Py_Void();
49527 }
49528
49529 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49530 return SWIG_Python_InitShadowInstance(args);
49531 }
49532
49533 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49534 PyObject *resultobj = 0;
49535 int arg1 = (int) 1 ;
49536 int arg2 = (int) 1 ;
49537 wxGBSpan *result = 0 ;
49538 int val1 ;
49539 int ecode1 = 0 ;
49540 int val2 ;
49541 int ecode2 = 0 ;
49542 PyObject * obj0 = 0 ;
49543 PyObject * obj1 = 0 ;
49544 char * kwnames[] = {
49545 (char *) "rowspan",(char *) "colspan", NULL
49546 };
49547
49548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49549 if (obj0) {
49550 ecode1 = SWIG_AsVal_int(obj0, &val1);
49551 if (!SWIG_IsOK(ecode1)) {
49552 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
49553 }
49554 arg1 = static_cast< int >(val1);
49555 }
49556 if (obj1) {
49557 ecode2 = SWIG_AsVal_int(obj1, &val2);
49558 if (!SWIG_IsOK(ecode2)) {
49559 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
49560 }
49561 arg2 = static_cast< int >(val2);
49562 }
49563 {
49564 PyThreadState* __tstate = wxPyBeginAllowThreads();
49565 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
49566 wxPyEndAllowThreads(__tstate);
49567 if (PyErr_Occurred()) SWIG_fail;
49568 }
49569 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
49570 return resultobj;
49571 fail:
49572 return NULL;
49573 }
49574
49575
49576 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49577 PyObject *resultobj = 0;
49578 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49579 void *argp1 = 0 ;
49580 int res1 = 0 ;
49581 PyObject *swig_obj[1] ;
49582
49583 if (!args) SWIG_fail;
49584 swig_obj[0] = args;
49585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
49586 if (!SWIG_IsOK(res1)) {
49587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49588 }
49589 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49590 {
49591 PyThreadState* __tstate = wxPyBeginAllowThreads();
49592 delete arg1;
49593
49594 wxPyEndAllowThreads(__tstate);
49595 if (PyErr_Occurred()) SWIG_fail;
49596 }
49597 resultobj = SWIG_Py_Void();
49598 return resultobj;
49599 fail:
49600 return NULL;
49601 }
49602
49603
49604 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49605 PyObject *resultobj = 0;
49606 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49607 int result;
49608 void *argp1 = 0 ;
49609 int res1 = 0 ;
49610 PyObject *swig_obj[1] ;
49611
49612 if (!args) SWIG_fail;
49613 swig_obj[0] = args;
49614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49615 if (!SWIG_IsOK(res1)) {
49616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49617 }
49618 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49619 {
49620 PyThreadState* __tstate = wxPyBeginAllowThreads();
49621 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
49622 wxPyEndAllowThreads(__tstate);
49623 if (PyErr_Occurred()) SWIG_fail;
49624 }
49625 resultobj = SWIG_From_int(static_cast< int >(result));
49626 return resultobj;
49627 fail:
49628 return NULL;
49629 }
49630
49631
49632 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49633 PyObject *resultobj = 0;
49634 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49635 int result;
49636 void *argp1 = 0 ;
49637 int res1 = 0 ;
49638 PyObject *swig_obj[1] ;
49639
49640 if (!args) SWIG_fail;
49641 swig_obj[0] = args;
49642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49643 if (!SWIG_IsOK(res1)) {
49644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49645 }
49646 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49647 {
49648 PyThreadState* __tstate = wxPyBeginAllowThreads();
49649 result = (int)((wxGBSpan const *)arg1)->GetColspan();
49650 wxPyEndAllowThreads(__tstate);
49651 if (PyErr_Occurred()) SWIG_fail;
49652 }
49653 resultobj = SWIG_From_int(static_cast< int >(result));
49654 return resultobj;
49655 fail:
49656 return NULL;
49657 }
49658
49659
49660 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49661 PyObject *resultobj = 0;
49662 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49663 int arg2 ;
49664 void *argp1 = 0 ;
49665 int res1 = 0 ;
49666 int val2 ;
49667 int ecode2 = 0 ;
49668 PyObject * obj0 = 0 ;
49669 PyObject * obj1 = 0 ;
49670 char * kwnames[] = {
49671 (char *) "self",(char *) "rowspan", NULL
49672 };
49673
49674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
49675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49676 if (!SWIG_IsOK(res1)) {
49677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49678 }
49679 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49680 ecode2 = SWIG_AsVal_int(obj1, &val2);
49681 if (!SWIG_IsOK(ecode2)) {
49682 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
49683 }
49684 arg2 = static_cast< int >(val2);
49685 {
49686 PyThreadState* __tstate = wxPyBeginAllowThreads();
49687 (arg1)->SetRowspan(arg2);
49688 wxPyEndAllowThreads(__tstate);
49689 if (PyErr_Occurred()) SWIG_fail;
49690 }
49691 resultobj = SWIG_Py_Void();
49692 return resultobj;
49693 fail:
49694 return NULL;
49695 }
49696
49697
49698 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49699 PyObject *resultobj = 0;
49700 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49701 int arg2 ;
49702 void *argp1 = 0 ;
49703 int res1 = 0 ;
49704 int val2 ;
49705 int ecode2 = 0 ;
49706 PyObject * obj0 = 0 ;
49707 PyObject * obj1 = 0 ;
49708 char * kwnames[] = {
49709 (char *) "self",(char *) "colspan", NULL
49710 };
49711
49712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
49713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49714 if (!SWIG_IsOK(res1)) {
49715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49716 }
49717 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49718 ecode2 = SWIG_AsVal_int(obj1, &val2);
49719 if (!SWIG_IsOK(ecode2)) {
49720 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
49721 }
49722 arg2 = static_cast< int >(val2);
49723 {
49724 PyThreadState* __tstate = wxPyBeginAllowThreads();
49725 (arg1)->SetColspan(arg2);
49726 wxPyEndAllowThreads(__tstate);
49727 if (PyErr_Occurred()) SWIG_fail;
49728 }
49729 resultobj = SWIG_Py_Void();
49730 return resultobj;
49731 fail:
49732 return NULL;
49733 }
49734
49735
49736 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49737 PyObject *resultobj = 0;
49738 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49739 PyObject *arg2 = (PyObject *) 0 ;
49740 bool result;
49741 void *argp1 = 0 ;
49742 int res1 = 0 ;
49743 PyObject * obj0 = 0 ;
49744 PyObject * obj1 = 0 ;
49745 char * kwnames[] = {
49746 (char *) "self",(char *) "other", NULL
49747 };
49748
49749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49751 if (!SWIG_IsOK(res1)) {
49752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49753 }
49754 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49755 arg2 = obj1;
49756 {
49757 result = (bool)wxGBSpan___eq__(arg1,arg2);
49758 if (PyErr_Occurred()) SWIG_fail;
49759 }
49760 {
49761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49762 }
49763 return resultobj;
49764 fail:
49765 return NULL;
49766 }
49767
49768
49769 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49770 PyObject *resultobj = 0;
49771 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49772 PyObject *arg2 = (PyObject *) 0 ;
49773 bool result;
49774 void *argp1 = 0 ;
49775 int res1 = 0 ;
49776 PyObject * obj0 = 0 ;
49777 PyObject * obj1 = 0 ;
49778 char * kwnames[] = {
49779 (char *) "self",(char *) "other", NULL
49780 };
49781
49782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49784 if (!SWIG_IsOK(res1)) {
49785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49786 }
49787 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49788 arg2 = obj1;
49789 {
49790 result = (bool)wxGBSpan___ne__(arg1,arg2);
49791 if (PyErr_Occurred()) SWIG_fail;
49792 }
49793 {
49794 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49795 }
49796 return resultobj;
49797 fail:
49798 return NULL;
49799 }
49800
49801
49802 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49803 PyObject *resultobj = 0;
49804 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49805 int arg2 = (int) 1 ;
49806 int arg3 = (int) 1 ;
49807 void *argp1 = 0 ;
49808 int res1 = 0 ;
49809 int val2 ;
49810 int ecode2 = 0 ;
49811 int val3 ;
49812 int ecode3 = 0 ;
49813 PyObject * obj0 = 0 ;
49814 PyObject * obj1 = 0 ;
49815 PyObject * obj2 = 0 ;
49816 char * kwnames[] = {
49817 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
49818 };
49819
49820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49822 if (!SWIG_IsOK(res1)) {
49823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49824 }
49825 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49826 if (obj1) {
49827 ecode2 = SWIG_AsVal_int(obj1, &val2);
49828 if (!SWIG_IsOK(ecode2)) {
49829 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
49830 }
49831 arg2 = static_cast< int >(val2);
49832 }
49833 if (obj2) {
49834 ecode3 = SWIG_AsVal_int(obj2, &val3);
49835 if (!SWIG_IsOK(ecode3)) {
49836 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
49837 }
49838 arg3 = static_cast< int >(val3);
49839 }
49840 {
49841 PyThreadState* __tstate = wxPyBeginAllowThreads();
49842 wxGBSpan_Set(arg1,arg2,arg3);
49843 wxPyEndAllowThreads(__tstate);
49844 if (PyErr_Occurred()) SWIG_fail;
49845 }
49846 resultobj = SWIG_Py_Void();
49847 return resultobj;
49848 fail:
49849 return NULL;
49850 }
49851
49852
49853 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49854 PyObject *resultobj = 0;
49855 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49856 PyObject *result = 0 ;
49857 void *argp1 = 0 ;
49858 int res1 = 0 ;
49859 PyObject *swig_obj[1] ;
49860
49861 if (!args) SWIG_fail;
49862 swig_obj[0] = args;
49863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49864 if (!SWIG_IsOK(res1)) {
49865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49866 }
49867 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49868 {
49869 PyThreadState* __tstate = wxPyBeginAllowThreads();
49870 result = (PyObject *)wxGBSpan_Get(arg1);
49871 wxPyEndAllowThreads(__tstate);
49872 if (PyErr_Occurred()) SWIG_fail;
49873 }
49874 resultobj = result;
49875 return resultobj;
49876 fail:
49877 return NULL;
49878 }
49879
49880
49881 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49882 PyObject *obj;
49883 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49884 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
49885 return SWIG_Py_Void();
49886 }
49887
49888 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49889 return SWIG_Python_InitShadowInstance(args);
49890 }
49891
49892 SWIGINTERN int DefaultSpan_set(PyObject *) {
49893 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
49894 return 1;
49895 }
49896
49897
49898 SWIGINTERN PyObject *DefaultSpan_get(void) {
49899 PyObject *pyobj = 0;
49900
49901 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
49902 return pyobj;
49903 }
49904
49905
49906 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49907 PyObject *resultobj = 0;
49908 wxGBSizerItem *result = 0 ;
49909
49910 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
49911 {
49912 PyThreadState* __tstate = wxPyBeginAllowThreads();
49913 result = (wxGBSizerItem *)new wxGBSizerItem();
49914 wxPyEndAllowThreads(__tstate);
49915 if (PyErr_Occurred()) SWIG_fail;
49916 }
49917 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
49918 return resultobj;
49919 fail:
49920 return NULL;
49921 }
49922
49923
49924 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49925 PyObject *resultobj = 0;
49926 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49927 void *argp1 = 0 ;
49928 int res1 = 0 ;
49929 PyObject *swig_obj[1] ;
49930
49931 if (!args) SWIG_fail;
49932 swig_obj[0] = args;
49933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49934 if (!SWIG_IsOK(res1)) {
49935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49936 }
49937 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49938 {
49939 PyThreadState* __tstate = wxPyBeginAllowThreads();
49940 delete arg1;
49941
49942 wxPyEndAllowThreads(__tstate);
49943 if (PyErr_Occurred()) SWIG_fail;
49944 }
49945 resultobj = SWIG_Py_Void();
49946 return resultobj;
49947 fail:
49948 return NULL;
49949 }
49950
49951
49952 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49953 PyObject *resultobj = 0;
49954 wxWindow *arg1 = (wxWindow *) 0 ;
49955 wxGBPosition *arg2 = 0 ;
49956 wxGBSpan *arg3 = 0 ;
49957 int arg4 ;
49958 int arg5 ;
49959 PyObject *arg6 = (PyObject *) NULL ;
49960 wxGBSizerItem *result = 0 ;
49961 void *argp1 = 0 ;
49962 int res1 = 0 ;
49963 wxGBPosition temp2 ;
49964 wxGBSpan temp3 ;
49965 int val4 ;
49966 int ecode4 = 0 ;
49967 int val5 ;
49968 int ecode5 = 0 ;
49969 PyObject * obj0 = 0 ;
49970 PyObject * obj1 = 0 ;
49971 PyObject * obj2 = 0 ;
49972 PyObject * obj3 = 0 ;
49973 PyObject * obj4 = 0 ;
49974 PyObject * obj5 = 0 ;
49975 char * kwnames[] = {
49976 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49977 };
49978
49979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
49981 if (!SWIG_IsOK(res1)) {
49982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
49983 }
49984 arg1 = reinterpret_cast< wxWindow * >(argp1);
49985 {
49986 arg2 = &temp2;
49987 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49988 }
49989 {
49990 arg3 = &temp3;
49991 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49992 }
49993 ecode4 = SWIG_AsVal_int(obj3, &val4);
49994 if (!SWIG_IsOK(ecode4)) {
49995 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
49996 }
49997 arg4 = static_cast< int >(val4);
49998 ecode5 = SWIG_AsVal_int(obj4, &val5);
49999 if (!SWIG_IsOK(ecode5)) {
50000 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
50001 }
50002 arg5 = static_cast< int >(val5);
50003 if (obj5) {
50004 arg6 = obj5;
50005 }
50006 {
50007 PyThreadState* __tstate = wxPyBeginAllowThreads();
50008 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
50009 wxPyEndAllowThreads(__tstate);
50010 if (PyErr_Occurred()) SWIG_fail;
50011 }
50012 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
50013 return resultobj;
50014 fail:
50015 return NULL;
50016 }
50017
50018
50019 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50020 PyObject *resultobj = 0;
50021 wxSizer *arg1 = (wxSizer *) 0 ;
50022 wxGBPosition *arg2 = 0 ;
50023 wxGBSpan *arg3 = 0 ;
50024 int arg4 ;
50025 int arg5 ;
50026 PyObject *arg6 = (PyObject *) NULL ;
50027 wxGBSizerItem *result = 0 ;
50028 int res1 = 0 ;
50029 wxGBPosition temp2 ;
50030 wxGBSpan temp3 ;
50031 int val4 ;
50032 int ecode4 = 0 ;
50033 int val5 ;
50034 int ecode5 = 0 ;
50035 PyObject * obj0 = 0 ;
50036 PyObject * obj1 = 0 ;
50037 PyObject * obj2 = 0 ;
50038 PyObject * obj3 = 0 ;
50039 PyObject * obj4 = 0 ;
50040 PyObject * obj5 = 0 ;
50041 char * kwnames[] = {
50042 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50043 };
50044
50045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
50046 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
50047 if (!SWIG_IsOK(res1)) {
50048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
50049 }
50050 {
50051 arg2 = &temp2;
50052 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50053 }
50054 {
50055 arg3 = &temp3;
50056 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50057 }
50058 ecode4 = SWIG_AsVal_int(obj3, &val4);
50059 if (!SWIG_IsOK(ecode4)) {
50060 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
50061 }
50062 arg4 = static_cast< int >(val4);
50063 ecode5 = SWIG_AsVal_int(obj4, &val5);
50064 if (!SWIG_IsOK(ecode5)) {
50065 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
50066 }
50067 arg5 = static_cast< int >(val5);
50068 if (obj5) {
50069 arg6 = obj5;
50070 }
50071 {
50072 PyThreadState* __tstate = wxPyBeginAllowThreads();
50073 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
50074 wxPyEndAllowThreads(__tstate);
50075 if (PyErr_Occurred()) SWIG_fail;
50076 }
50077 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
50078 return resultobj;
50079 fail:
50080 return NULL;
50081 }
50082
50083
50084 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50085 PyObject *resultobj = 0;
50086 int arg1 ;
50087 int arg2 ;
50088 wxGBPosition *arg3 = 0 ;
50089 wxGBSpan *arg4 = 0 ;
50090 int arg5 ;
50091 int arg6 ;
50092 PyObject *arg7 = (PyObject *) NULL ;
50093 wxGBSizerItem *result = 0 ;
50094 int val1 ;
50095 int ecode1 = 0 ;
50096 int val2 ;
50097 int ecode2 = 0 ;
50098 wxGBPosition temp3 ;
50099 wxGBSpan temp4 ;
50100 int val5 ;
50101 int ecode5 = 0 ;
50102 int val6 ;
50103 int ecode6 = 0 ;
50104 PyObject * obj0 = 0 ;
50105 PyObject * obj1 = 0 ;
50106 PyObject * obj2 = 0 ;
50107 PyObject * obj3 = 0 ;
50108 PyObject * obj4 = 0 ;
50109 PyObject * obj5 = 0 ;
50110 PyObject * obj6 = 0 ;
50111 char * kwnames[] = {
50112 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50113 };
50114
50115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
50116 ecode1 = SWIG_AsVal_int(obj0, &val1);
50117 if (!SWIG_IsOK(ecode1)) {
50118 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
50119 }
50120 arg1 = static_cast< int >(val1);
50121 ecode2 = SWIG_AsVal_int(obj1, &val2);
50122 if (!SWIG_IsOK(ecode2)) {
50123 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
50124 }
50125 arg2 = static_cast< int >(val2);
50126 {
50127 arg3 = &temp3;
50128 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
50129 }
50130 {
50131 arg4 = &temp4;
50132 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
50133 }
50134 ecode5 = SWIG_AsVal_int(obj4, &val5);
50135 if (!SWIG_IsOK(ecode5)) {
50136 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
50137 }
50138 arg5 = static_cast< int >(val5);
50139 ecode6 = SWIG_AsVal_int(obj5, &val6);
50140 if (!SWIG_IsOK(ecode6)) {
50141 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
50142 }
50143 arg6 = static_cast< int >(val6);
50144 if (obj6) {
50145 arg7 = obj6;
50146 }
50147 {
50148 PyThreadState* __tstate = wxPyBeginAllowThreads();
50149 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
50150 wxPyEndAllowThreads(__tstate);
50151 if (PyErr_Occurred()) SWIG_fail;
50152 }
50153 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
50154 return resultobj;
50155 fail:
50156 return NULL;
50157 }
50158
50159
50160 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50161 PyObject *resultobj = 0;
50162 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50163 wxGBPosition result;
50164 void *argp1 = 0 ;
50165 int res1 = 0 ;
50166 PyObject *swig_obj[1] ;
50167
50168 if (!args) SWIG_fail;
50169 swig_obj[0] = args;
50170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50171 if (!SWIG_IsOK(res1)) {
50172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50173 }
50174 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50175 {
50176 PyThreadState* __tstate = wxPyBeginAllowThreads();
50177 result = ((wxGBSizerItem const *)arg1)->GetPos();
50178 wxPyEndAllowThreads(__tstate);
50179 if (PyErr_Occurred()) SWIG_fail;
50180 }
50181 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50182 return resultobj;
50183 fail:
50184 return NULL;
50185 }
50186
50187
50188 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50189 PyObject *resultobj = 0;
50190 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50191 wxGBSpan result;
50192 void *argp1 = 0 ;
50193 int res1 = 0 ;
50194 PyObject *swig_obj[1] ;
50195
50196 if (!args) SWIG_fail;
50197 swig_obj[0] = args;
50198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50199 if (!SWIG_IsOK(res1)) {
50200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50201 }
50202 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50203 {
50204 PyThreadState* __tstate = wxPyBeginAllowThreads();
50205 result = ((wxGBSizerItem const *)arg1)->GetSpan();
50206 wxPyEndAllowThreads(__tstate);
50207 if (PyErr_Occurred()) SWIG_fail;
50208 }
50209 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50210 return resultobj;
50211 fail:
50212 return NULL;
50213 }
50214
50215
50216 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50217 PyObject *resultobj = 0;
50218 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50219 wxGBPosition *arg2 = 0 ;
50220 bool result;
50221 void *argp1 = 0 ;
50222 int res1 = 0 ;
50223 wxGBPosition temp2 ;
50224 PyObject * obj0 = 0 ;
50225 PyObject * obj1 = 0 ;
50226 char * kwnames[] = {
50227 (char *) "self",(char *) "pos", NULL
50228 };
50229
50230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
50231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50232 if (!SWIG_IsOK(res1)) {
50233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50234 }
50235 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50236 {
50237 arg2 = &temp2;
50238 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50239 }
50240 {
50241 PyThreadState* __tstate = wxPyBeginAllowThreads();
50242 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
50243 wxPyEndAllowThreads(__tstate);
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_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50256 PyObject *resultobj = 0;
50257 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50258 wxGBSpan *arg2 = 0 ;
50259 bool result;
50260 void *argp1 = 0 ;
50261 int res1 = 0 ;
50262 wxGBSpan temp2 ;
50263 PyObject * obj0 = 0 ;
50264 PyObject * obj1 = 0 ;
50265 char * kwnames[] = {
50266 (char *) "self",(char *) "span", NULL
50267 };
50268
50269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
50270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50271 if (!SWIG_IsOK(res1)) {
50272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50273 }
50274 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50275 {
50276 arg2 = &temp2;
50277 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
50278 }
50279 {
50280 PyThreadState* __tstate = wxPyBeginAllowThreads();
50281 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
50282 wxPyEndAllowThreads(__tstate);
50283 if (PyErr_Occurred()) SWIG_fail;
50284 }
50285 {
50286 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50287 }
50288 return resultobj;
50289 fail:
50290 return NULL;
50291 }
50292
50293
50294 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50295 PyObject *resultobj = 0;
50296 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50297 wxGBSizerItem *arg2 = 0 ;
50298 bool result;
50299 void *argp1 = 0 ;
50300 int res1 = 0 ;
50301 void *argp2 = 0 ;
50302 int res2 = 0 ;
50303 PyObject * obj0 = 0 ;
50304 PyObject * obj1 = 0 ;
50305 char * kwnames[] = {
50306 (char *) "self",(char *) "other", NULL
50307 };
50308
50309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
50310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50311 if (!SWIG_IsOK(res1)) {
50312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50313 }
50314 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50315 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
50316 if (!SWIG_IsOK(res2)) {
50317 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
50318 }
50319 if (!argp2) {
50320 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
50321 }
50322 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
50323 {
50324 PyThreadState* __tstate = wxPyBeginAllowThreads();
50325 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
50326 wxPyEndAllowThreads(__tstate);
50327 if (PyErr_Occurred()) SWIG_fail;
50328 }
50329 {
50330 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50331 }
50332 return resultobj;
50333 fail:
50334 return NULL;
50335 }
50336
50337
50338 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50339 PyObject *resultobj = 0;
50340 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50341 wxGBPosition *arg2 = 0 ;
50342 wxGBSpan *arg3 = 0 ;
50343 bool result;
50344 void *argp1 = 0 ;
50345 int res1 = 0 ;
50346 wxGBPosition temp2 ;
50347 wxGBSpan temp3 ;
50348 PyObject * obj0 = 0 ;
50349 PyObject * obj1 = 0 ;
50350 PyObject * obj2 = 0 ;
50351 char * kwnames[] = {
50352 (char *) "self",(char *) "pos",(char *) "span", NULL
50353 };
50354
50355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50357 if (!SWIG_IsOK(res1)) {
50358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50359 }
50360 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50361 {
50362 arg2 = &temp2;
50363 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50364 }
50365 {
50366 arg3 = &temp3;
50367 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50368 }
50369 {
50370 PyThreadState* __tstate = wxPyBeginAllowThreads();
50371 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
50372 wxPyEndAllowThreads(__tstate);
50373 if (PyErr_Occurred()) SWIG_fail;
50374 }
50375 {
50376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50377 }
50378 return resultobj;
50379 fail:
50380 return NULL;
50381 }
50382
50383
50384 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50385 PyObject *resultobj = 0;
50386 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50387 wxGBPosition result;
50388 void *argp1 = 0 ;
50389 int res1 = 0 ;
50390 PyObject *swig_obj[1] ;
50391
50392 if (!args) SWIG_fail;
50393 swig_obj[0] = args;
50394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50395 if (!SWIG_IsOK(res1)) {
50396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50397 }
50398 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50399 {
50400 PyThreadState* __tstate = wxPyBeginAllowThreads();
50401 result = wxGBSizerItem_GetEndPos(arg1);
50402 wxPyEndAllowThreads(__tstate);
50403 if (PyErr_Occurred()) SWIG_fail;
50404 }
50405 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50406 return resultobj;
50407 fail:
50408 return NULL;
50409 }
50410
50411
50412 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50413 PyObject *resultobj = 0;
50414 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50415 wxGridBagSizer *result = 0 ;
50416 void *argp1 = 0 ;
50417 int res1 = 0 ;
50418 PyObject *swig_obj[1] ;
50419
50420 if (!args) SWIG_fail;
50421 swig_obj[0] = args;
50422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50423 if (!SWIG_IsOK(res1)) {
50424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50425 }
50426 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50427 {
50428 PyThreadState* __tstate = wxPyBeginAllowThreads();
50429 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
50430 wxPyEndAllowThreads(__tstate);
50431 if (PyErr_Occurred()) SWIG_fail;
50432 }
50433 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50434 return resultobj;
50435 fail:
50436 return NULL;
50437 }
50438
50439
50440 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50441 PyObject *resultobj = 0;
50442 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50443 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
50444 void *argp1 = 0 ;
50445 int res1 = 0 ;
50446 void *argp2 = 0 ;
50447 int res2 = 0 ;
50448 PyObject * obj0 = 0 ;
50449 PyObject * obj1 = 0 ;
50450 char * kwnames[] = {
50451 (char *) "self",(char *) "sizer", NULL
50452 };
50453
50454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50455 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50456 if (!SWIG_IsOK(res1)) {
50457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50458 }
50459 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50460 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50461 if (!SWIG_IsOK(res2)) {
50462 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
50463 }
50464 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
50465 {
50466 PyThreadState* __tstate = wxPyBeginAllowThreads();
50467 (arg1)->SetGBSizer(arg2);
50468 wxPyEndAllowThreads(__tstate);
50469 if (PyErr_Occurred()) SWIG_fail;
50470 }
50471 resultobj = SWIG_Py_Void();
50472 return resultobj;
50473 fail:
50474 return NULL;
50475 }
50476
50477
50478 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50479 PyObject *obj;
50480 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50481 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
50482 return SWIG_Py_Void();
50483 }
50484
50485 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50486 return SWIG_Python_InitShadowInstance(args);
50487 }
50488
50489 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50490 PyObject *resultobj = 0;
50491 int arg1 = (int) 0 ;
50492 int arg2 = (int) 0 ;
50493 wxGridBagSizer *result = 0 ;
50494 int val1 ;
50495 int ecode1 = 0 ;
50496 int val2 ;
50497 int ecode2 = 0 ;
50498 PyObject * obj0 = 0 ;
50499 PyObject * obj1 = 0 ;
50500 char * kwnames[] = {
50501 (char *) "vgap",(char *) "hgap", NULL
50502 };
50503
50504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50505 if (obj0) {
50506 ecode1 = SWIG_AsVal_int(obj0, &val1);
50507 if (!SWIG_IsOK(ecode1)) {
50508 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
50509 }
50510 arg1 = static_cast< int >(val1);
50511 }
50512 if (obj1) {
50513 ecode2 = SWIG_AsVal_int(obj1, &val2);
50514 if (!SWIG_IsOK(ecode2)) {
50515 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
50516 }
50517 arg2 = static_cast< int >(val2);
50518 }
50519 {
50520 PyThreadState* __tstate = wxPyBeginAllowThreads();
50521 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
50522 wxPyEndAllowThreads(__tstate);
50523 if (PyErr_Occurred()) SWIG_fail;
50524 }
50525 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
50526 return resultobj;
50527 fail:
50528 return NULL;
50529 }
50530
50531
50532 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50533 PyObject *resultobj = 0;
50534 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50535 PyObject *arg2 = (PyObject *) 0 ;
50536 wxGBPosition *arg3 = 0 ;
50537 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
50538 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
50539 int arg5 = (int) 0 ;
50540 int arg6 = (int) 0 ;
50541 PyObject *arg7 = (PyObject *) NULL ;
50542 wxGBSizerItem *result = 0 ;
50543 void *argp1 = 0 ;
50544 int res1 = 0 ;
50545 wxGBPosition temp3 ;
50546 wxGBSpan temp4 ;
50547 int val5 ;
50548 int ecode5 = 0 ;
50549 int val6 ;
50550 int ecode6 = 0 ;
50551 PyObject * obj0 = 0 ;
50552 PyObject * obj1 = 0 ;
50553 PyObject * obj2 = 0 ;
50554 PyObject * obj3 = 0 ;
50555 PyObject * obj4 = 0 ;
50556 PyObject * obj5 = 0 ;
50557 PyObject * obj6 = 0 ;
50558 char * kwnames[] = {
50559 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50560 };
50561
50562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
50563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50564 if (!SWIG_IsOK(res1)) {
50565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50566 }
50567 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50568 arg2 = obj1;
50569 {
50570 arg3 = &temp3;
50571 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
50572 }
50573 if (obj3) {
50574 {
50575 arg4 = &temp4;
50576 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
50577 }
50578 }
50579 if (obj4) {
50580 ecode5 = SWIG_AsVal_int(obj4, &val5);
50581 if (!SWIG_IsOK(ecode5)) {
50582 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
50583 }
50584 arg5 = static_cast< int >(val5);
50585 }
50586 if (obj5) {
50587 ecode6 = SWIG_AsVal_int(obj5, &val6);
50588 if (!SWIG_IsOK(ecode6)) {
50589 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
50590 }
50591 arg6 = static_cast< int >(val6);
50592 }
50593 if (obj6) {
50594 arg7 = obj6;
50595 }
50596 {
50597 PyThreadState* __tstate = wxPyBeginAllowThreads();
50598 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
50599 wxPyEndAllowThreads(__tstate);
50600 if (PyErr_Occurred()) SWIG_fail;
50601 }
50602 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50603 return resultobj;
50604 fail:
50605 return NULL;
50606 }
50607
50608
50609 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50610 PyObject *resultobj = 0;
50611 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50612 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
50613 wxGBSizerItem *result = 0 ;
50614 void *argp1 = 0 ;
50615 int res1 = 0 ;
50616 int res2 = 0 ;
50617 PyObject * obj0 = 0 ;
50618 PyObject * obj1 = 0 ;
50619 char * kwnames[] = {
50620 (char *) "self",(char *) "item", NULL
50621 };
50622
50623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50625 if (!SWIG_IsOK(res1)) {
50626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50627 }
50628 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50629 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
50630 if (!SWIG_IsOK(res2)) {
50631 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
50632 }
50633 {
50634 PyThreadState* __tstate = wxPyBeginAllowThreads();
50635 result = (wxGBSizerItem *)(arg1)->Add(arg2);
50636 wxPyEndAllowThreads(__tstate);
50637 if (PyErr_Occurred()) SWIG_fail;
50638 }
50639 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50640 return resultobj;
50641 fail:
50642 return NULL;
50643 }
50644
50645
50646 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50647 PyObject *resultobj = 0;
50648 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50649 int arg2 ;
50650 int arg3 ;
50651 wxSize result;
50652 void *argp1 = 0 ;
50653 int res1 = 0 ;
50654 int val2 ;
50655 int ecode2 = 0 ;
50656 int val3 ;
50657 int ecode3 = 0 ;
50658 PyObject * obj0 = 0 ;
50659 PyObject * obj1 = 0 ;
50660 PyObject * obj2 = 0 ;
50661 char * kwnames[] = {
50662 (char *) "self",(char *) "row",(char *) "col", NULL
50663 };
50664
50665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50667 if (!SWIG_IsOK(res1)) {
50668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50669 }
50670 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50671 ecode2 = SWIG_AsVal_int(obj1, &val2);
50672 if (!SWIG_IsOK(ecode2)) {
50673 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
50674 }
50675 arg2 = static_cast< int >(val2);
50676 ecode3 = SWIG_AsVal_int(obj2, &val3);
50677 if (!SWIG_IsOK(ecode3)) {
50678 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
50679 }
50680 arg3 = static_cast< int >(val3);
50681 {
50682 PyThreadState* __tstate = wxPyBeginAllowThreads();
50683 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
50684 wxPyEndAllowThreads(__tstate);
50685 if (PyErr_Occurred()) SWIG_fail;
50686 }
50687 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50688 return resultobj;
50689 fail:
50690 return NULL;
50691 }
50692
50693
50694 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50695 PyObject *resultobj = 0;
50696 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50697 wxSize result;
50698 void *argp1 = 0 ;
50699 int res1 = 0 ;
50700 PyObject *swig_obj[1] ;
50701
50702 if (!args) SWIG_fail;
50703 swig_obj[0] = args;
50704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50705 if (!SWIG_IsOK(res1)) {
50706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50707 }
50708 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50709 {
50710 PyThreadState* __tstate = wxPyBeginAllowThreads();
50711 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
50712 wxPyEndAllowThreads(__tstate);
50713 if (PyErr_Occurred()) SWIG_fail;
50714 }
50715 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50716 return resultobj;
50717 fail:
50718 return NULL;
50719 }
50720
50721
50722 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50723 PyObject *resultobj = 0;
50724 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50725 wxSize *arg2 = 0 ;
50726 void *argp1 = 0 ;
50727 int res1 = 0 ;
50728 wxSize temp2 ;
50729 PyObject * obj0 = 0 ;
50730 PyObject * obj1 = 0 ;
50731 char * kwnames[] = {
50732 (char *) "self",(char *) "sz", NULL
50733 };
50734
50735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
50736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50737 if (!SWIG_IsOK(res1)) {
50738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50739 }
50740 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50741 {
50742 arg2 = &temp2;
50743 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50744 }
50745 {
50746 PyThreadState* __tstate = wxPyBeginAllowThreads();
50747 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
50748 wxPyEndAllowThreads(__tstate);
50749 if (PyErr_Occurred()) SWIG_fail;
50750 }
50751 resultobj = SWIG_Py_Void();
50752 return resultobj;
50753 fail:
50754 return NULL;
50755 }
50756
50757
50758 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50759 PyObject *resultobj = 0;
50760 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50761 wxWindow *arg2 = (wxWindow *) 0 ;
50762 wxGBPosition result;
50763 void *argp1 = 0 ;
50764 int res1 = 0 ;
50765 void *argp2 = 0 ;
50766 int res2 = 0 ;
50767
50768 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50770 if (!SWIG_IsOK(res1)) {
50771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50772 }
50773 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50774 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50775 if (!SWIG_IsOK(res2)) {
50776 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50777 }
50778 arg2 = reinterpret_cast< wxWindow * >(argp2);
50779 {
50780 PyThreadState* __tstate = wxPyBeginAllowThreads();
50781 result = (arg1)->GetItemPosition(arg2);
50782 wxPyEndAllowThreads(__tstate);
50783 if (PyErr_Occurred()) SWIG_fail;
50784 }
50785 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50786 return resultobj;
50787 fail:
50788 return NULL;
50789 }
50790
50791
50792 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50793 PyObject *resultobj = 0;
50794 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50795 wxSizer *arg2 = (wxSizer *) 0 ;
50796 wxGBPosition result;
50797 void *argp1 = 0 ;
50798 int res1 = 0 ;
50799 void *argp2 = 0 ;
50800 int res2 = 0 ;
50801
50802 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50804 if (!SWIG_IsOK(res1)) {
50805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50806 }
50807 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50808 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50809 if (!SWIG_IsOK(res2)) {
50810 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50811 }
50812 arg2 = reinterpret_cast< wxSizer * >(argp2);
50813 {
50814 PyThreadState* __tstate = wxPyBeginAllowThreads();
50815 result = (arg1)->GetItemPosition(arg2);
50816 wxPyEndAllowThreads(__tstate);
50817 if (PyErr_Occurred()) SWIG_fail;
50818 }
50819 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50820 return resultobj;
50821 fail:
50822 return NULL;
50823 }
50824
50825
50826 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50827 PyObject *resultobj = 0;
50828 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50829 size_t arg2 ;
50830 wxGBPosition result;
50831 void *argp1 = 0 ;
50832 int res1 = 0 ;
50833 size_t val2 ;
50834 int ecode2 = 0 ;
50835
50836 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50838 if (!SWIG_IsOK(res1)) {
50839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50840 }
50841 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50842 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50843 if (!SWIG_IsOK(ecode2)) {
50844 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50845 }
50846 arg2 = static_cast< size_t >(val2);
50847 {
50848 PyThreadState* __tstate = wxPyBeginAllowThreads();
50849 result = (arg1)->GetItemPosition(arg2);
50850 wxPyEndAllowThreads(__tstate);
50851 if (PyErr_Occurred()) SWIG_fail;
50852 }
50853 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50854 return resultobj;
50855 fail:
50856 return NULL;
50857 }
50858
50859
50860 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
50861 int argc;
50862 PyObject *argv[3];
50863
50864 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
50865 --argc;
50866 if (argc == 2) {
50867 int _v = 0;
50868 {
50869 void *vptr = 0;
50870 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50871 _v = SWIG_CheckState(res);
50872 }
50873 if (!_v) goto check_1;
50874 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
50875 }
50876 check_1:
50877
50878 if (argc == 2) {
50879 int _v = 0;
50880 {
50881 void *vptr = 0;
50882 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50883 _v = SWIG_CheckState(res);
50884 }
50885 if (!_v) goto check_2;
50886 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
50887 }
50888 check_2:
50889
50890 if (argc == 2) {
50891 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
50892 }
50893
50894 fail:
50895 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
50896 return NULL;
50897 }
50898
50899
50900 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50901 PyObject *resultobj = 0;
50902 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50903 wxWindow *arg2 = (wxWindow *) 0 ;
50904 wxGBPosition *arg3 = 0 ;
50905 bool result;
50906 void *argp1 = 0 ;
50907 int res1 = 0 ;
50908 void *argp2 = 0 ;
50909 int res2 = 0 ;
50910 wxGBPosition temp3 ;
50911
50912 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50914 if (!SWIG_IsOK(res1)) {
50915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50916 }
50917 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50918 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50919 if (!SWIG_IsOK(res2)) {
50920 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50921 }
50922 arg2 = reinterpret_cast< wxWindow * >(argp2);
50923 {
50924 arg3 = &temp3;
50925 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50926 }
50927 {
50928 PyThreadState* __tstate = wxPyBeginAllowThreads();
50929 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50930 wxPyEndAllowThreads(__tstate);
50931 if (PyErr_Occurred()) SWIG_fail;
50932 }
50933 {
50934 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50935 }
50936 return resultobj;
50937 fail:
50938 return NULL;
50939 }
50940
50941
50942 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50943 PyObject *resultobj = 0;
50944 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50945 wxSizer *arg2 = (wxSizer *) 0 ;
50946 wxGBPosition *arg3 = 0 ;
50947 bool result;
50948 void *argp1 = 0 ;
50949 int res1 = 0 ;
50950 void *argp2 = 0 ;
50951 int res2 = 0 ;
50952 wxGBPosition temp3 ;
50953
50954 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50956 if (!SWIG_IsOK(res1)) {
50957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50958 }
50959 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50960 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50961 if (!SWIG_IsOK(res2)) {
50962 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50963 }
50964 arg2 = reinterpret_cast< wxSizer * >(argp2);
50965 {
50966 arg3 = &temp3;
50967 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50968 }
50969 {
50970 PyThreadState* __tstate = wxPyBeginAllowThreads();
50971 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50972 wxPyEndAllowThreads(__tstate);
50973 if (PyErr_Occurred()) SWIG_fail;
50974 }
50975 {
50976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50977 }
50978 return resultobj;
50979 fail:
50980 return NULL;
50981 }
50982
50983
50984 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50985 PyObject *resultobj = 0;
50986 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50987 size_t arg2 ;
50988 wxGBPosition *arg3 = 0 ;
50989 bool result;
50990 void *argp1 = 0 ;
50991 int res1 = 0 ;
50992 size_t val2 ;
50993 int ecode2 = 0 ;
50994 wxGBPosition temp3 ;
50995
50996 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50998 if (!SWIG_IsOK(res1)) {
50999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51000 }
51001 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51002 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51003 if (!SWIG_IsOK(ecode2)) {
51004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
51005 }
51006 arg2 = static_cast< size_t >(val2);
51007 {
51008 arg3 = &temp3;
51009 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
51010 }
51011 {
51012 PyThreadState* __tstate = wxPyBeginAllowThreads();
51013 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
51014 wxPyEndAllowThreads(__tstate);
51015 if (PyErr_Occurred()) SWIG_fail;
51016 }
51017 {
51018 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51019 }
51020 return resultobj;
51021 fail:
51022 return NULL;
51023 }
51024
51025
51026 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
51027 int argc;
51028 PyObject *argv[4];
51029
51030 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
51031 --argc;
51032 if (argc == 3) {
51033 int _v = 0;
51034 {
51035 void *vptr = 0;
51036 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51037 _v = SWIG_CheckState(res);
51038 }
51039 if (!_v) goto check_1;
51040 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
51041 }
51042 check_1:
51043
51044 if (argc == 3) {
51045 int _v = 0;
51046 {
51047 void *vptr = 0;
51048 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51049 _v = SWIG_CheckState(res);
51050 }
51051 if (!_v) goto check_2;
51052 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
51053 }
51054 check_2:
51055
51056 if (argc == 3) {
51057 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
51058 }
51059
51060 fail:
51061 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
51062 return NULL;
51063 }
51064
51065
51066 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51067 PyObject *resultobj = 0;
51068 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51069 wxWindow *arg2 = (wxWindow *) 0 ;
51070 wxGBSpan result;
51071 void *argp1 = 0 ;
51072 int res1 = 0 ;
51073 void *argp2 = 0 ;
51074 int res2 = 0 ;
51075
51076 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51078 if (!SWIG_IsOK(res1)) {
51079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51080 }
51081 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51082 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51083 if (!SWIG_IsOK(res2)) {
51084 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
51085 }
51086 arg2 = reinterpret_cast< wxWindow * >(argp2);
51087 {
51088 PyThreadState* __tstate = wxPyBeginAllowThreads();
51089 result = (arg1)->GetItemSpan(arg2);
51090 wxPyEndAllowThreads(__tstate);
51091 if (PyErr_Occurred()) SWIG_fail;
51092 }
51093 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51094 return resultobj;
51095 fail:
51096 return NULL;
51097 }
51098
51099
51100 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51101 PyObject *resultobj = 0;
51102 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51103 wxSizer *arg2 = (wxSizer *) 0 ;
51104 wxGBSpan result;
51105 void *argp1 = 0 ;
51106 int res1 = 0 ;
51107 void *argp2 = 0 ;
51108 int res2 = 0 ;
51109
51110 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51112 if (!SWIG_IsOK(res1)) {
51113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51114 }
51115 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51116 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51117 if (!SWIG_IsOK(res2)) {
51118 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
51119 }
51120 arg2 = reinterpret_cast< wxSizer * >(argp2);
51121 {
51122 PyThreadState* __tstate = wxPyBeginAllowThreads();
51123 result = (arg1)->GetItemSpan(arg2);
51124 wxPyEndAllowThreads(__tstate);
51125 if (PyErr_Occurred()) SWIG_fail;
51126 }
51127 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51128 return resultobj;
51129 fail:
51130 return NULL;
51131 }
51132
51133
51134 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51135 PyObject *resultobj = 0;
51136 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51137 size_t arg2 ;
51138 wxGBSpan result;
51139 void *argp1 = 0 ;
51140 int res1 = 0 ;
51141 size_t val2 ;
51142 int ecode2 = 0 ;
51143
51144 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51146 if (!SWIG_IsOK(res1)) {
51147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51148 }
51149 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51150 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51151 if (!SWIG_IsOK(ecode2)) {
51152 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
51153 }
51154 arg2 = static_cast< size_t >(val2);
51155 {
51156 PyThreadState* __tstate = wxPyBeginAllowThreads();
51157 result = (arg1)->GetItemSpan(arg2);
51158 wxPyEndAllowThreads(__tstate);
51159 if (PyErr_Occurred()) SWIG_fail;
51160 }
51161 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51162 return resultobj;
51163 fail:
51164 return NULL;
51165 }
51166
51167
51168 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
51169 int argc;
51170 PyObject *argv[3];
51171
51172 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
51173 --argc;
51174 if (argc == 2) {
51175 int _v = 0;
51176 {
51177 void *vptr = 0;
51178 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51179 _v = SWIG_CheckState(res);
51180 }
51181 if (!_v) goto check_1;
51182 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
51183 }
51184 check_1:
51185
51186 if (argc == 2) {
51187 int _v = 0;
51188 {
51189 void *vptr = 0;
51190 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51191 _v = SWIG_CheckState(res);
51192 }
51193 if (!_v) goto check_2;
51194 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
51195 }
51196 check_2:
51197
51198 if (argc == 2) {
51199 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
51200 }
51201
51202 fail:
51203 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
51204 return NULL;
51205 }
51206
51207
51208 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51209 PyObject *resultobj = 0;
51210 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51211 wxWindow *arg2 = (wxWindow *) 0 ;
51212 wxGBSpan *arg3 = 0 ;
51213 bool result;
51214 void *argp1 = 0 ;
51215 int res1 = 0 ;
51216 void *argp2 = 0 ;
51217 int res2 = 0 ;
51218 wxGBSpan temp3 ;
51219
51220 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51222 if (!SWIG_IsOK(res1)) {
51223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51224 }
51225 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51226 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51227 if (!SWIG_IsOK(res2)) {
51228 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
51229 }
51230 arg2 = reinterpret_cast< wxWindow * >(argp2);
51231 {
51232 arg3 = &temp3;
51233 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51234 }
51235 {
51236 PyThreadState* __tstate = wxPyBeginAllowThreads();
51237 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51238 wxPyEndAllowThreads(__tstate);
51239 if (PyErr_Occurred()) SWIG_fail;
51240 }
51241 {
51242 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51243 }
51244 return resultobj;
51245 fail:
51246 return NULL;
51247 }
51248
51249
51250 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51251 PyObject *resultobj = 0;
51252 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51253 wxSizer *arg2 = (wxSizer *) 0 ;
51254 wxGBSpan *arg3 = 0 ;
51255 bool result;
51256 void *argp1 = 0 ;
51257 int res1 = 0 ;
51258 void *argp2 = 0 ;
51259 int res2 = 0 ;
51260 wxGBSpan temp3 ;
51261
51262 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51264 if (!SWIG_IsOK(res1)) {
51265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51266 }
51267 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51268 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51269 if (!SWIG_IsOK(res2)) {
51270 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
51271 }
51272 arg2 = reinterpret_cast< wxSizer * >(argp2);
51273 {
51274 arg3 = &temp3;
51275 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51276 }
51277 {
51278 PyThreadState* __tstate = wxPyBeginAllowThreads();
51279 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51280 wxPyEndAllowThreads(__tstate);
51281 if (PyErr_Occurred()) SWIG_fail;
51282 }
51283 {
51284 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51285 }
51286 return resultobj;
51287 fail:
51288 return NULL;
51289 }
51290
51291
51292 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51293 PyObject *resultobj = 0;
51294 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51295 size_t arg2 ;
51296 wxGBSpan *arg3 = 0 ;
51297 bool result;
51298 void *argp1 = 0 ;
51299 int res1 = 0 ;
51300 size_t val2 ;
51301 int ecode2 = 0 ;
51302 wxGBSpan temp3 ;
51303
51304 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51306 if (!SWIG_IsOK(res1)) {
51307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51308 }
51309 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51310 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51311 if (!SWIG_IsOK(ecode2)) {
51312 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
51313 }
51314 arg2 = static_cast< size_t >(val2);
51315 {
51316 arg3 = &temp3;
51317 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51318 }
51319 {
51320 PyThreadState* __tstate = wxPyBeginAllowThreads();
51321 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51322 wxPyEndAllowThreads(__tstate);
51323 if (PyErr_Occurred()) SWIG_fail;
51324 }
51325 {
51326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51327 }
51328 return resultobj;
51329 fail:
51330 return NULL;
51331 }
51332
51333
51334 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
51335 int argc;
51336 PyObject *argv[4];
51337
51338 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
51339 --argc;
51340 if (argc == 3) {
51341 int _v = 0;
51342 {
51343 void *vptr = 0;
51344 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51345 _v = SWIG_CheckState(res);
51346 }
51347 if (!_v) goto check_1;
51348 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
51349 }
51350 check_1:
51351
51352 if (argc == 3) {
51353 int _v = 0;
51354 {
51355 void *vptr = 0;
51356 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51357 _v = SWIG_CheckState(res);
51358 }
51359 if (!_v) goto check_2;
51360 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
51361 }
51362 check_2:
51363
51364 if (argc == 3) {
51365 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
51366 }
51367
51368 fail:
51369 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
51370 return NULL;
51371 }
51372
51373
51374 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51375 PyObject *resultobj = 0;
51376 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51377 wxWindow *arg2 = (wxWindow *) 0 ;
51378 wxGBSizerItem *result = 0 ;
51379 void *argp1 = 0 ;
51380 int res1 = 0 ;
51381 void *argp2 = 0 ;
51382 int res2 = 0 ;
51383
51384 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51386 if (!SWIG_IsOK(res1)) {
51387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51388 }
51389 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51390 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51391 if (!SWIG_IsOK(res2)) {
51392 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
51393 }
51394 arg2 = reinterpret_cast< wxWindow * >(argp2);
51395 {
51396 PyThreadState* __tstate = wxPyBeginAllowThreads();
51397 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
51398 wxPyEndAllowThreads(__tstate);
51399 if (PyErr_Occurred()) SWIG_fail;
51400 }
51401 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51402 return resultobj;
51403 fail:
51404 return NULL;
51405 }
51406
51407
51408 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51409 PyObject *resultobj = 0;
51410 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51411 wxSizer *arg2 = (wxSizer *) 0 ;
51412 wxGBSizerItem *result = 0 ;
51413 void *argp1 = 0 ;
51414 int res1 = 0 ;
51415 void *argp2 = 0 ;
51416 int res2 = 0 ;
51417
51418 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51420 if (!SWIG_IsOK(res1)) {
51421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51422 }
51423 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51424 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51425 if (!SWIG_IsOK(res2)) {
51426 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
51427 }
51428 arg2 = reinterpret_cast< wxSizer * >(argp2);
51429 {
51430 PyThreadState* __tstate = wxPyBeginAllowThreads();
51431 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
51432 wxPyEndAllowThreads(__tstate);
51433 if (PyErr_Occurred()) SWIG_fail;
51434 }
51435 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51436 return resultobj;
51437 fail:
51438 return NULL;
51439 }
51440
51441
51442 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
51443 int argc;
51444 PyObject *argv[3];
51445
51446 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
51447 --argc;
51448 if (argc == 2) {
51449 int _v = 0;
51450 {
51451 void *vptr = 0;
51452 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51453 _v = SWIG_CheckState(res);
51454 }
51455 if (!_v) goto check_1;
51456 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
51457 }
51458 check_1:
51459
51460 if (argc == 2) {
51461 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
51462 }
51463
51464 fail:
51465 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
51466 return NULL;
51467 }
51468
51469
51470 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51471 PyObject *resultobj = 0;
51472 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51473 wxGBPosition *arg2 = 0 ;
51474 wxGBSizerItem *result = 0 ;
51475 void *argp1 = 0 ;
51476 int res1 = 0 ;
51477 wxGBPosition temp2 ;
51478 PyObject * obj0 = 0 ;
51479 PyObject * obj1 = 0 ;
51480 char * kwnames[] = {
51481 (char *) "self",(char *) "pos", NULL
51482 };
51483
51484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
51485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51486 if (!SWIG_IsOK(res1)) {
51487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51488 }
51489 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51490 {
51491 arg2 = &temp2;
51492 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51493 }
51494 {
51495 PyThreadState* __tstate = wxPyBeginAllowThreads();
51496 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
51497 wxPyEndAllowThreads(__tstate);
51498 if (PyErr_Occurred()) SWIG_fail;
51499 }
51500 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51501 return resultobj;
51502 fail:
51503 return NULL;
51504 }
51505
51506
51507 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51508 PyObject *resultobj = 0;
51509 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51510 wxPoint *arg2 = 0 ;
51511 wxGBSizerItem *result = 0 ;
51512 void *argp1 = 0 ;
51513 int res1 = 0 ;
51514 wxPoint temp2 ;
51515 PyObject * obj0 = 0 ;
51516 PyObject * obj1 = 0 ;
51517 char * kwnames[] = {
51518 (char *) "self",(char *) "pt", NULL
51519 };
51520
51521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
51522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51523 if (!SWIG_IsOK(res1)) {
51524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51525 }
51526 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51527 {
51528 arg2 = &temp2;
51529 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
51530 }
51531 {
51532 PyThreadState* __tstate = wxPyBeginAllowThreads();
51533 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
51534 wxPyEndAllowThreads(__tstate);
51535 if (PyErr_Occurred()) SWIG_fail;
51536 }
51537 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51538 return resultobj;
51539 fail:
51540 return NULL;
51541 }
51542
51543
51544 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51545 PyObject *resultobj = 0;
51546 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51547 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
51548 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
51549 bool result;
51550 void *argp1 = 0 ;
51551 int res1 = 0 ;
51552 void *argp2 = 0 ;
51553 int res2 = 0 ;
51554 void *argp3 = 0 ;
51555 int res3 = 0 ;
51556 PyObject * obj0 = 0 ;
51557 PyObject * obj1 = 0 ;
51558 PyObject * obj2 = 0 ;
51559 char * kwnames[] = {
51560 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
51561 };
51562
51563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51565 if (!SWIG_IsOK(res1)) {
51566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51567 }
51568 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51569 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51570 if (!SWIG_IsOK(res2)) {
51571 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51572 }
51573 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
51574 if (obj2) {
51575 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51576 if (!SWIG_IsOK(res3)) {
51577 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
51578 }
51579 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
51580 }
51581 {
51582 PyThreadState* __tstate = wxPyBeginAllowThreads();
51583 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
51584 wxPyEndAllowThreads(__tstate);
51585 if (PyErr_Occurred()) SWIG_fail;
51586 }
51587 {
51588 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51589 }
51590 return resultobj;
51591 fail:
51592 return NULL;
51593 }
51594
51595
51596 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51597 PyObject *resultobj = 0;
51598 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51599 wxGBPosition *arg2 = 0 ;
51600 wxGBSpan *arg3 = 0 ;
51601 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
51602 bool result;
51603 void *argp1 = 0 ;
51604 int res1 = 0 ;
51605 wxGBPosition temp2 ;
51606 wxGBSpan temp3 ;
51607 void *argp4 = 0 ;
51608 int res4 = 0 ;
51609 PyObject * obj0 = 0 ;
51610 PyObject * obj1 = 0 ;
51611 PyObject * obj2 = 0 ;
51612 PyObject * obj3 = 0 ;
51613 char * kwnames[] = {
51614 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
51615 };
51616
51617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51619 if (!SWIG_IsOK(res1)) {
51620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51621 }
51622 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51623 {
51624 arg2 = &temp2;
51625 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51626 }
51627 {
51628 arg3 = &temp3;
51629 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51630 }
51631 if (obj3) {
51632 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51633 if (!SWIG_IsOK(res4)) {
51634 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
51635 }
51636 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
51637 }
51638 {
51639 PyThreadState* __tstate = wxPyBeginAllowThreads();
51640 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
51641 wxPyEndAllowThreads(__tstate);
51642 if (PyErr_Occurred()) SWIG_fail;
51643 }
51644 {
51645 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51646 }
51647 return resultobj;
51648 fail:
51649 return NULL;
51650 }
51651
51652
51653 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51654 PyObject *obj;
51655 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51656 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
51657 return SWIG_Py_Void();
51658 }
51659
51660 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51661 return SWIG_Python_InitShadowInstance(args);
51662 }
51663
51664 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51665 PyObject *resultobj = 0;
51666 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51667 wxRelationship arg2 ;
51668 wxWindow *arg3 = (wxWindow *) 0 ;
51669 wxEdge arg4 ;
51670 int arg5 = (int) 0 ;
51671 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
51672 void *argp1 = 0 ;
51673 int res1 = 0 ;
51674 int val2 ;
51675 int ecode2 = 0 ;
51676 void *argp3 = 0 ;
51677 int res3 = 0 ;
51678 int val4 ;
51679 int ecode4 = 0 ;
51680 int val5 ;
51681 int ecode5 = 0 ;
51682 int val6 ;
51683 int ecode6 = 0 ;
51684 PyObject * obj0 = 0 ;
51685 PyObject * obj1 = 0 ;
51686 PyObject * obj2 = 0 ;
51687 PyObject * obj3 = 0 ;
51688 PyObject * obj4 = 0 ;
51689 PyObject * obj5 = 0 ;
51690 char * kwnames[] = {
51691 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
51692 };
51693
51694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51696 if (!SWIG_IsOK(res1)) {
51697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51698 }
51699 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51700 ecode2 = SWIG_AsVal_int(obj1, &val2);
51701 if (!SWIG_IsOK(ecode2)) {
51702 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
51703 }
51704 arg2 = static_cast< wxRelationship >(val2);
51705 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51706 if (!SWIG_IsOK(res3)) {
51707 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
51708 }
51709 arg3 = reinterpret_cast< wxWindow * >(argp3);
51710 ecode4 = SWIG_AsVal_int(obj3, &val4);
51711 if (!SWIG_IsOK(ecode4)) {
51712 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
51713 }
51714 arg4 = static_cast< wxEdge >(val4);
51715 if (obj4) {
51716 ecode5 = SWIG_AsVal_int(obj4, &val5);
51717 if (!SWIG_IsOK(ecode5)) {
51718 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
51719 }
51720 arg5 = static_cast< int >(val5);
51721 }
51722 if (obj5) {
51723 ecode6 = SWIG_AsVal_int(obj5, &val6);
51724 if (!SWIG_IsOK(ecode6)) {
51725 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
51726 }
51727 arg6 = static_cast< int >(val6);
51728 }
51729 {
51730 PyThreadState* __tstate = wxPyBeginAllowThreads();
51731 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
51732 wxPyEndAllowThreads(__tstate);
51733 if (PyErr_Occurred()) SWIG_fail;
51734 }
51735 resultobj = SWIG_Py_Void();
51736 return resultobj;
51737 fail:
51738 return NULL;
51739 }
51740
51741
51742 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51743 PyObject *resultobj = 0;
51744 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51745 wxWindow *arg2 = (wxWindow *) 0 ;
51746 int arg3 = (int) 0 ;
51747 void *argp1 = 0 ;
51748 int res1 = 0 ;
51749 void *argp2 = 0 ;
51750 int res2 = 0 ;
51751 int val3 ;
51752 int ecode3 = 0 ;
51753 PyObject * obj0 = 0 ;
51754 PyObject * obj1 = 0 ;
51755 PyObject * obj2 = 0 ;
51756 char * kwnames[] = {
51757 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51758 };
51759
51760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51762 if (!SWIG_IsOK(res1)) {
51763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51764 }
51765 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51766 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51767 if (!SWIG_IsOK(res2)) {
51768 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51769 }
51770 arg2 = reinterpret_cast< wxWindow * >(argp2);
51771 if (obj2) {
51772 ecode3 = SWIG_AsVal_int(obj2, &val3);
51773 if (!SWIG_IsOK(ecode3)) {
51774 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
51775 }
51776 arg3 = static_cast< int >(val3);
51777 }
51778 {
51779 PyThreadState* __tstate = wxPyBeginAllowThreads();
51780 (arg1)->LeftOf(arg2,arg3);
51781 wxPyEndAllowThreads(__tstate);
51782 if (PyErr_Occurred()) SWIG_fail;
51783 }
51784 resultobj = SWIG_Py_Void();
51785 return resultobj;
51786 fail:
51787 return NULL;
51788 }
51789
51790
51791 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51792 PyObject *resultobj = 0;
51793 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51794 wxWindow *arg2 = (wxWindow *) 0 ;
51795 int arg3 = (int) 0 ;
51796 void *argp1 = 0 ;
51797 int res1 = 0 ;
51798 void *argp2 = 0 ;
51799 int res2 = 0 ;
51800 int val3 ;
51801 int ecode3 = 0 ;
51802 PyObject * obj0 = 0 ;
51803 PyObject * obj1 = 0 ;
51804 PyObject * obj2 = 0 ;
51805 char * kwnames[] = {
51806 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51807 };
51808
51809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51811 if (!SWIG_IsOK(res1)) {
51812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51813 }
51814 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51815 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51816 if (!SWIG_IsOK(res2)) {
51817 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51818 }
51819 arg2 = reinterpret_cast< wxWindow * >(argp2);
51820 if (obj2) {
51821 ecode3 = SWIG_AsVal_int(obj2, &val3);
51822 if (!SWIG_IsOK(ecode3)) {
51823 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
51824 }
51825 arg3 = static_cast< int >(val3);
51826 }
51827 {
51828 PyThreadState* __tstate = wxPyBeginAllowThreads();
51829 (arg1)->RightOf(arg2,arg3);
51830 wxPyEndAllowThreads(__tstate);
51831 if (PyErr_Occurred()) SWIG_fail;
51832 }
51833 resultobj = SWIG_Py_Void();
51834 return resultobj;
51835 fail:
51836 return NULL;
51837 }
51838
51839
51840 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51841 PyObject *resultobj = 0;
51842 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51843 wxWindow *arg2 = (wxWindow *) 0 ;
51844 int arg3 = (int) 0 ;
51845 void *argp1 = 0 ;
51846 int res1 = 0 ;
51847 void *argp2 = 0 ;
51848 int res2 = 0 ;
51849 int val3 ;
51850 int ecode3 = 0 ;
51851 PyObject * obj0 = 0 ;
51852 PyObject * obj1 = 0 ;
51853 PyObject * obj2 = 0 ;
51854 char * kwnames[] = {
51855 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51856 };
51857
51858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51860 if (!SWIG_IsOK(res1)) {
51861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51862 }
51863 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51864 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51865 if (!SWIG_IsOK(res2)) {
51866 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
51867 }
51868 arg2 = reinterpret_cast< wxWindow * >(argp2);
51869 if (obj2) {
51870 ecode3 = SWIG_AsVal_int(obj2, &val3);
51871 if (!SWIG_IsOK(ecode3)) {
51872 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
51873 }
51874 arg3 = static_cast< int >(val3);
51875 }
51876 {
51877 PyThreadState* __tstate = wxPyBeginAllowThreads();
51878 (arg1)->Above(arg2,arg3);
51879 wxPyEndAllowThreads(__tstate);
51880 if (PyErr_Occurred()) SWIG_fail;
51881 }
51882 resultobj = SWIG_Py_Void();
51883 return resultobj;
51884 fail:
51885 return NULL;
51886 }
51887
51888
51889 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51890 PyObject *resultobj = 0;
51891 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51892 wxWindow *arg2 = (wxWindow *) 0 ;
51893 int arg3 = (int) 0 ;
51894 void *argp1 = 0 ;
51895 int res1 = 0 ;
51896 void *argp2 = 0 ;
51897 int res2 = 0 ;
51898 int val3 ;
51899 int ecode3 = 0 ;
51900 PyObject * obj0 = 0 ;
51901 PyObject * obj1 = 0 ;
51902 PyObject * obj2 = 0 ;
51903 char * kwnames[] = {
51904 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51905 };
51906
51907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51909 if (!SWIG_IsOK(res1)) {
51910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51911 }
51912 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51913 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51914 if (!SWIG_IsOK(res2)) {
51915 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
51916 }
51917 arg2 = reinterpret_cast< wxWindow * >(argp2);
51918 if (obj2) {
51919 ecode3 = SWIG_AsVal_int(obj2, &val3);
51920 if (!SWIG_IsOK(ecode3)) {
51921 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
51922 }
51923 arg3 = static_cast< int >(val3);
51924 }
51925 {
51926 PyThreadState* __tstate = wxPyBeginAllowThreads();
51927 (arg1)->Below(arg2,arg3);
51928 wxPyEndAllowThreads(__tstate);
51929 if (PyErr_Occurred()) SWIG_fail;
51930 }
51931 resultobj = SWIG_Py_Void();
51932 return resultobj;
51933 fail:
51934 return NULL;
51935 }
51936
51937
51938 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51939 PyObject *resultobj = 0;
51940 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51941 wxWindow *arg2 = (wxWindow *) 0 ;
51942 wxEdge arg3 ;
51943 int arg4 = (int) 0 ;
51944 void *argp1 = 0 ;
51945 int res1 = 0 ;
51946 void *argp2 = 0 ;
51947 int res2 = 0 ;
51948 int val3 ;
51949 int ecode3 = 0 ;
51950 int val4 ;
51951 int ecode4 = 0 ;
51952 PyObject * obj0 = 0 ;
51953 PyObject * obj1 = 0 ;
51954 PyObject * obj2 = 0 ;
51955 PyObject * obj3 = 0 ;
51956 char * kwnames[] = {
51957 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
51958 };
51959
51960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51962 if (!SWIG_IsOK(res1)) {
51963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51964 }
51965 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51966 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51967 if (!SWIG_IsOK(res2)) {
51968 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
51969 }
51970 arg2 = reinterpret_cast< wxWindow * >(argp2);
51971 ecode3 = SWIG_AsVal_int(obj2, &val3);
51972 if (!SWIG_IsOK(ecode3)) {
51973 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
51974 }
51975 arg3 = static_cast< wxEdge >(val3);
51976 if (obj3) {
51977 ecode4 = SWIG_AsVal_int(obj3, &val4);
51978 if (!SWIG_IsOK(ecode4)) {
51979 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
51980 }
51981 arg4 = static_cast< int >(val4);
51982 }
51983 {
51984 PyThreadState* __tstate = wxPyBeginAllowThreads();
51985 (arg1)->SameAs(arg2,arg3,arg4);
51986 wxPyEndAllowThreads(__tstate);
51987 if (PyErr_Occurred()) SWIG_fail;
51988 }
51989 resultobj = SWIG_Py_Void();
51990 return resultobj;
51991 fail:
51992 return NULL;
51993 }
51994
51995
51996 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51997 PyObject *resultobj = 0;
51998 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51999 wxWindow *arg2 = (wxWindow *) 0 ;
52000 wxEdge arg3 ;
52001 int arg4 ;
52002 void *argp1 = 0 ;
52003 int res1 = 0 ;
52004 void *argp2 = 0 ;
52005 int res2 = 0 ;
52006 int val3 ;
52007 int ecode3 = 0 ;
52008 int val4 ;
52009 int ecode4 = 0 ;
52010 PyObject * obj0 = 0 ;
52011 PyObject * obj1 = 0 ;
52012 PyObject * obj2 = 0 ;
52013 PyObject * obj3 = 0 ;
52014 char * kwnames[] = {
52015 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
52016 };
52017
52018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52020 if (!SWIG_IsOK(res1)) {
52021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52022 }
52023 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52024 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52025 if (!SWIG_IsOK(res2)) {
52026 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
52027 }
52028 arg2 = reinterpret_cast< wxWindow * >(argp2);
52029 ecode3 = SWIG_AsVal_int(obj2, &val3);
52030 if (!SWIG_IsOK(ecode3)) {
52031 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
52032 }
52033 arg3 = static_cast< wxEdge >(val3);
52034 ecode4 = SWIG_AsVal_int(obj3, &val4);
52035 if (!SWIG_IsOK(ecode4)) {
52036 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
52037 }
52038 arg4 = static_cast< int >(val4);
52039 {
52040 PyThreadState* __tstate = wxPyBeginAllowThreads();
52041 (arg1)->PercentOf(arg2,arg3,arg4);
52042 wxPyEndAllowThreads(__tstate);
52043 if (PyErr_Occurred()) SWIG_fail;
52044 }
52045 resultobj = SWIG_Py_Void();
52046 return resultobj;
52047 fail:
52048 return NULL;
52049 }
52050
52051
52052 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52053 PyObject *resultobj = 0;
52054 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52055 int arg2 ;
52056 void *argp1 = 0 ;
52057 int res1 = 0 ;
52058 int val2 ;
52059 int ecode2 = 0 ;
52060 PyObject * obj0 = 0 ;
52061 PyObject * obj1 = 0 ;
52062 char * kwnames[] = {
52063 (char *) "self",(char *) "val", NULL
52064 };
52065
52066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
52067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52068 if (!SWIG_IsOK(res1)) {
52069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52070 }
52071 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52072 ecode2 = SWIG_AsVal_int(obj1, &val2);
52073 if (!SWIG_IsOK(ecode2)) {
52074 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
52075 }
52076 arg2 = static_cast< int >(val2);
52077 {
52078 PyThreadState* __tstate = wxPyBeginAllowThreads();
52079 (arg1)->Absolute(arg2);
52080 wxPyEndAllowThreads(__tstate);
52081 if (PyErr_Occurred()) SWIG_fail;
52082 }
52083 resultobj = SWIG_Py_Void();
52084 return resultobj;
52085 fail:
52086 return NULL;
52087 }
52088
52089
52090 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52091 PyObject *resultobj = 0;
52092 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52093 void *argp1 = 0 ;
52094 int res1 = 0 ;
52095 PyObject *swig_obj[1] ;
52096
52097 if (!args) SWIG_fail;
52098 swig_obj[0] = args;
52099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52100 if (!SWIG_IsOK(res1)) {
52101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52102 }
52103 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52104 {
52105 PyThreadState* __tstate = wxPyBeginAllowThreads();
52106 (arg1)->Unconstrained();
52107 wxPyEndAllowThreads(__tstate);
52108 if (PyErr_Occurred()) SWIG_fail;
52109 }
52110 resultobj = SWIG_Py_Void();
52111 return resultobj;
52112 fail:
52113 return NULL;
52114 }
52115
52116
52117 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52118 PyObject *resultobj = 0;
52119 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52120 void *argp1 = 0 ;
52121 int res1 = 0 ;
52122 PyObject *swig_obj[1] ;
52123
52124 if (!args) SWIG_fail;
52125 swig_obj[0] = args;
52126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52127 if (!SWIG_IsOK(res1)) {
52128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52129 }
52130 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52131 {
52132 PyThreadState* __tstate = wxPyBeginAllowThreads();
52133 (arg1)->AsIs();
52134 wxPyEndAllowThreads(__tstate);
52135 if (PyErr_Occurred()) SWIG_fail;
52136 }
52137 resultobj = SWIG_Py_Void();
52138 return resultobj;
52139 fail:
52140 return NULL;
52141 }
52142
52143
52144 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52145 PyObject *resultobj = 0;
52146 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52147 wxWindow *result = 0 ;
52148 void *argp1 = 0 ;
52149 int res1 = 0 ;
52150 PyObject *swig_obj[1] ;
52151
52152 if (!args) SWIG_fail;
52153 swig_obj[0] = args;
52154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52155 if (!SWIG_IsOK(res1)) {
52156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52157 }
52158 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52159 {
52160 PyThreadState* __tstate = wxPyBeginAllowThreads();
52161 result = (wxWindow *)(arg1)->GetOtherWindow();
52162 wxPyEndAllowThreads(__tstate);
52163 if (PyErr_Occurred()) SWIG_fail;
52164 }
52165 {
52166 resultobj = wxPyMake_wxObject(result, 0);
52167 }
52168 return resultobj;
52169 fail:
52170 return NULL;
52171 }
52172
52173
52174 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52175 PyObject *resultobj = 0;
52176 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52177 wxEdge result;
52178 void *argp1 = 0 ;
52179 int res1 = 0 ;
52180 PyObject *swig_obj[1] ;
52181
52182 if (!args) SWIG_fail;
52183 swig_obj[0] = args;
52184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52185 if (!SWIG_IsOK(res1)) {
52186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52187 }
52188 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52189 {
52190 PyThreadState* __tstate = wxPyBeginAllowThreads();
52191 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
52192 wxPyEndAllowThreads(__tstate);
52193 if (PyErr_Occurred()) SWIG_fail;
52194 }
52195 resultobj = SWIG_From_int(static_cast< int >(result));
52196 return resultobj;
52197 fail:
52198 return NULL;
52199 }
52200
52201
52202 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52203 PyObject *resultobj = 0;
52204 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52205 wxEdge arg2 ;
52206 void *argp1 = 0 ;
52207 int res1 = 0 ;
52208 int val2 ;
52209 int ecode2 = 0 ;
52210 PyObject * obj0 = 0 ;
52211 PyObject * obj1 = 0 ;
52212 char * kwnames[] = {
52213 (char *) "self",(char *) "which", NULL
52214 };
52215
52216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
52217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52218 if (!SWIG_IsOK(res1)) {
52219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52220 }
52221 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52222 ecode2 = SWIG_AsVal_int(obj1, &val2);
52223 if (!SWIG_IsOK(ecode2)) {
52224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52225 }
52226 arg2 = static_cast< wxEdge >(val2);
52227 {
52228 PyThreadState* __tstate = wxPyBeginAllowThreads();
52229 (arg1)->SetEdge(arg2);
52230 wxPyEndAllowThreads(__tstate);
52231 if (PyErr_Occurred()) SWIG_fail;
52232 }
52233 resultobj = SWIG_Py_Void();
52234 return resultobj;
52235 fail:
52236 return NULL;
52237 }
52238
52239
52240 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52241 PyObject *resultobj = 0;
52242 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52243 int arg2 ;
52244 void *argp1 = 0 ;
52245 int res1 = 0 ;
52246 int val2 ;
52247 int ecode2 = 0 ;
52248 PyObject * obj0 = 0 ;
52249 PyObject * obj1 = 0 ;
52250 char * kwnames[] = {
52251 (char *) "self",(char *) "v", NULL
52252 };
52253
52254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
52255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52256 if (!SWIG_IsOK(res1)) {
52257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52258 }
52259 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52260 ecode2 = SWIG_AsVal_int(obj1, &val2);
52261 if (!SWIG_IsOK(ecode2)) {
52262 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
52263 }
52264 arg2 = static_cast< int >(val2);
52265 {
52266 PyThreadState* __tstate = wxPyBeginAllowThreads();
52267 (arg1)->SetValue(arg2);
52268 wxPyEndAllowThreads(__tstate);
52269 if (PyErr_Occurred()) SWIG_fail;
52270 }
52271 resultobj = SWIG_Py_Void();
52272 return resultobj;
52273 fail:
52274 return NULL;
52275 }
52276
52277
52278 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52279 PyObject *resultobj = 0;
52280 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52281 int result;
52282 void *argp1 = 0 ;
52283 int res1 = 0 ;
52284 PyObject *swig_obj[1] ;
52285
52286 if (!args) SWIG_fail;
52287 swig_obj[0] = args;
52288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52289 if (!SWIG_IsOK(res1)) {
52290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52291 }
52292 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52293 {
52294 PyThreadState* __tstate = wxPyBeginAllowThreads();
52295 result = (int)(arg1)->GetMargin();
52296 wxPyEndAllowThreads(__tstate);
52297 if (PyErr_Occurred()) SWIG_fail;
52298 }
52299 resultobj = SWIG_From_int(static_cast< int >(result));
52300 return resultobj;
52301 fail:
52302 return NULL;
52303 }
52304
52305
52306 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52307 PyObject *resultobj = 0;
52308 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52309 int arg2 ;
52310 void *argp1 = 0 ;
52311 int res1 = 0 ;
52312 int val2 ;
52313 int ecode2 = 0 ;
52314 PyObject * obj0 = 0 ;
52315 PyObject * obj1 = 0 ;
52316 char * kwnames[] = {
52317 (char *) "self",(char *) "m", NULL
52318 };
52319
52320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
52321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52322 if (!SWIG_IsOK(res1)) {
52323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52324 }
52325 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52326 ecode2 = SWIG_AsVal_int(obj1, &val2);
52327 if (!SWIG_IsOK(ecode2)) {
52328 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
52329 }
52330 arg2 = static_cast< int >(val2);
52331 {
52332 PyThreadState* __tstate = wxPyBeginAllowThreads();
52333 (arg1)->SetMargin(arg2);
52334 wxPyEndAllowThreads(__tstate);
52335 if (PyErr_Occurred()) SWIG_fail;
52336 }
52337 resultobj = SWIG_Py_Void();
52338 return resultobj;
52339 fail:
52340 return NULL;
52341 }
52342
52343
52344 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52345 PyObject *resultobj = 0;
52346 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52347 int result;
52348 void *argp1 = 0 ;
52349 int res1 = 0 ;
52350 PyObject *swig_obj[1] ;
52351
52352 if (!args) SWIG_fail;
52353 swig_obj[0] = args;
52354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52355 if (!SWIG_IsOK(res1)) {
52356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52357 }
52358 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52359 {
52360 PyThreadState* __tstate = wxPyBeginAllowThreads();
52361 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
52362 wxPyEndAllowThreads(__tstate);
52363 if (PyErr_Occurred()) SWIG_fail;
52364 }
52365 resultobj = SWIG_From_int(static_cast< int >(result));
52366 return resultobj;
52367 fail:
52368 return NULL;
52369 }
52370
52371
52372 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52373 PyObject *resultobj = 0;
52374 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52375 int result;
52376 void *argp1 = 0 ;
52377 int res1 = 0 ;
52378 PyObject *swig_obj[1] ;
52379
52380 if (!args) SWIG_fail;
52381 swig_obj[0] = args;
52382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52383 if (!SWIG_IsOK(res1)) {
52384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52385 }
52386 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52387 {
52388 PyThreadState* __tstate = wxPyBeginAllowThreads();
52389 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
52390 wxPyEndAllowThreads(__tstate);
52391 if (PyErr_Occurred()) SWIG_fail;
52392 }
52393 resultobj = SWIG_From_int(static_cast< int >(result));
52394 return resultobj;
52395 fail:
52396 return NULL;
52397 }
52398
52399
52400 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52401 PyObject *resultobj = 0;
52402 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52403 int result;
52404 void *argp1 = 0 ;
52405 int res1 = 0 ;
52406 PyObject *swig_obj[1] ;
52407
52408 if (!args) SWIG_fail;
52409 swig_obj[0] = args;
52410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52411 if (!SWIG_IsOK(res1)) {
52412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52413 }
52414 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52415 {
52416 PyThreadState* __tstate = wxPyBeginAllowThreads();
52417 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
52418 wxPyEndAllowThreads(__tstate);
52419 if (PyErr_Occurred()) SWIG_fail;
52420 }
52421 resultobj = SWIG_From_int(static_cast< int >(result));
52422 return resultobj;
52423 fail:
52424 return NULL;
52425 }
52426
52427
52428 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52429 PyObject *resultobj = 0;
52430 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52431 bool result;
52432 void *argp1 = 0 ;
52433 int res1 = 0 ;
52434 PyObject *swig_obj[1] ;
52435
52436 if (!args) SWIG_fail;
52437 swig_obj[0] = args;
52438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52439 if (!SWIG_IsOK(res1)) {
52440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52441 }
52442 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52443 {
52444 PyThreadState* __tstate = wxPyBeginAllowThreads();
52445 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
52446 wxPyEndAllowThreads(__tstate);
52447 if (PyErr_Occurred()) SWIG_fail;
52448 }
52449 {
52450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52451 }
52452 return resultobj;
52453 fail:
52454 return NULL;
52455 }
52456
52457
52458 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52459 PyObject *resultobj = 0;
52460 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52461 bool arg2 ;
52462 void *argp1 = 0 ;
52463 int res1 = 0 ;
52464 bool val2 ;
52465 int ecode2 = 0 ;
52466 PyObject * obj0 = 0 ;
52467 PyObject * obj1 = 0 ;
52468 char * kwnames[] = {
52469 (char *) "self",(char *) "d", NULL
52470 };
52471
52472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
52473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52474 if (!SWIG_IsOK(res1)) {
52475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52476 }
52477 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52478 ecode2 = SWIG_AsVal_bool(obj1, &val2);
52479 if (!SWIG_IsOK(ecode2)) {
52480 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
52481 }
52482 arg2 = static_cast< bool >(val2);
52483 {
52484 PyThreadState* __tstate = wxPyBeginAllowThreads();
52485 (arg1)->SetDone(arg2);
52486 wxPyEndAllowThreads(__tstate);
52487 if (PyErr_Occurred()) SWIG_fail;
52488 }
52489 resultobj = SWIG_Py_Void();
52490 return resultobj;
52491 fail:
52492 return NULL;
52493 }
52494
52495
52496 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52497 PyObject *resultobj = 0;
52498 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52499 wxRelationship result;
52500 void *argp1 = 0 ;
52501 int res1 = 0 ;
52502 PyObject *swig_obj[1] ;
52503
52504 if (!args) SWIG_fail;
52505 swig_obj[0] = args;
52506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52507 if (!SWIG_IsOK(res1)) {
52508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52509 }
52510 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52511 {
52512 PyThreadState* __tstate = wxPyBeginAllowThreads();
52513 result = (wxRelationship)(arg1)->GetRelationship();
52514 wxPyEndAllowThreads(__tstate);
52515 if (PyErr_Occurred()) SWIG_fail;
52516 }
52517 resultobj = SWIG_From_int(static_cast< int >(result));
52518 return resultobj;
52519 fail:
52520 return NULL;
52521 }
52522
52523
52524 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52525 PyObject *resultobj = 0;
52526 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52527 wxRelationship arg2 ;
52528 void *argp1 = 0 ;
52529 int res1 = 0 ;
52530 int val2 ;
52531 int ecode2 = 0 ;
52532 PyObject * obj0 = 0 ;
52533 PyObject * obj1 = 0 ;
52534 char * kwnames[] = {
52535 (char *) "self",(char *) "r", NULL
52536 };
52537
52538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
52539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52540 if (!SWIG_IsOK(res1)) {
52541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52542 }
52543 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52544 ecode2 = SWIG_AsVal_int(obj1, &val2);
52545 if (!SWIG_IsOK(ecode2)) {
52546 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
52547 }
52548 arg2 = static_cast< wxRelationship >(val2);
52549 {
52550 PyThreadState* __tstate = wxPyBeginAllowThreads();
52551 (arg1)->SetRelationship(arg2);
52552 wxPyEndAllowThreads(__tstate);
52553 if (PyErr_Occurred()) SWIG_fail;
52554 }
52555 resultobj = SWIG_Py_Void();
52556 return resultobj;
52557 fail:
52558 return NULL;
52559 }
52560
52561
52562 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52563 PyObject *resultobj = 0;
52564 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52565 wxWindow *arg2 = (wxWindow *) 0 ;
52566 bool result;
52567 void *argp1 = 0 ;
52568 int res1 = 0 ;
52569 void *argp2 = 0 ;
52570 int res2 = 0 ;
52571 PyObject * obj0 = 0 ;
52572 PyObject * obj1 = 0 ;
52573 char * kwnames[] = {
52574 (char *) "self",(char *) "otherW", NULL
52575 };
52576
52577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
52578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52579 if (!SWIG_IsOK(res1)) {
52580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52581 }
52582 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52583 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52584 if (!SWIG_IsOK(res2)) {
52585 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
52586 }
52587 arg2 = reinterpret_cast< wxWindow * >(argp2);
52588 {
52589 PyThreadState* __tstate = wxPyBeginAllowThreads();
52590 result = (bool)(arg1)->ResetIfWin(arg2);
52591 wxPyEndAllowThreads(__tstate);
52592 if (PyErr_Occurred()) SWIG_fail;
52593 }
52594 {
52595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52596 }
52597 return resultobj;
52598 fail:
52599 return NULL;
52600 }
52601
52602
52603 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52604 PyObject *resultobj = 0;
52605 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52606 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
52607 wxWindow *arg3 = (wxWindow *) 0 ;
52608 bool result;
52609 void *argp1 = 0 ;
52610 int res1 = 0 ;
52611 void *argp2 = 0 ;
52612 int res2 = 0 ;
52613 void *argp3 = 0 ;
52614 int res3 = 0 ;
52615 PyObject * obj0 = 0 ;
52616 PyObject * obj1 = 0 ;
52617 PyObject * obj2 = 0 ;
52618 char * kwnames[] = {
52619 (char *) "self",(char *) "constraints",(char *) "win", NULL
52620 };
52621
52622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52624 if (!SWIG_IsOK(res1)) {
52625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52626 }
52627 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52628 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52629 if (!SWIG_IsOK(res2)) {
52630 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
52631 }
52632 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
52633 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52634 if (!SWIG_IsOK(res3)) {
52635 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
52636 }
52637 arg3 = reinterpret_cast< wxWindow * >(argp3);
52638 {
52639 PyThreadState* __tstate = wxPyBeginAllowThreads();
52640 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
52641 wxPyEndAllowThreads(__tstate);
52642 if (PyErr_Occurred()) SWIG_fail;
52643 }
52644 {
52645 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52646 }
52647 return resultobj;
52648 fail:
52649 return NULL;
52650 }
52651
52652
52653 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52654 PyObject *resultobj = 0;
52655 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52656 wxEdge arg2 ;
52657 wxWindow *arg3 = (wxWindow *) 0 ;
52658 wxWindow *arg4 = (wxWindow *) 0 ;
52659 int result;
52660 void *argp1 = 0 ;
52661 int res1 = 0 ;
52662 int val2 ;
52663 int ecode2 = 0 ;
52664 void *argp3 = 0 ;
52665 int res3 = 0 ;
52666 void *argp4 = 0 ;
52667 int res4 = 0 ;
52668 PyObject * obj0 = 0 ;
52669 PyObject * obj1 = 0 ;
52670 PyObject * obj2 = 0 ;
52671 PyObject * obj3 = 0 ;
52672 char * kwnames[] = {
52673 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
52674 };
52675
52676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52678 if (!SWIG_IsOK(res1)) {
52679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52680 }
52681 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52682 ecode2 = SWIG_AsVal_int(obj1, &val2);
52683 if (!SWIG_IsOK(ecode2)) {
52684 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52685 }
52686 arg2 = static_cast< wxEdge >(val2);
52687 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52688 if (!SWIG_IsOK(res3)) {
52689 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
52690 }
52691 arg3 = reinterpret_cast< wxWindow * >(argp3);
52692 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
52693 if (!SWIG_IsOK(res4)) {
52694 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
52695 }
52696 arg4 = reinterpret_cast< wxWindow * >(argp4);
52697 {
52698 PyThreadState* __tstate = wxPyBeginAllowThreads();
52699 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
52700 wxPyEndAllowThreads(__tstate);
52701 if (PyErr_Occurred()) SWIG_fail;
52702 }
52703 resultobj = SWIG_From_int(static_cast< int >(result));
52704 return resultobj;
52705 fail:
52706 return NULL;
52707 }
52708
52709
52710 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52711 PyObject *obj;
52712 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52713 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
52714 return SWIG_Py_Void();
52715 }
52716
52717 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52718 PyObject *resultobj = 0;
52719 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52720 wxIndividualLayoutConstraint *result = 0 ;
52721 void *argp1 = 0 ;
52722 int res1 = 0 ;
52723 PyObject *swig_obj[1] ;
52724
52725 if (!args) SWIG_fail;
52726 swig_obj[0] = args;
52727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52728 if (!SWIG_IsOK(res1)) {
52729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52730 }
52731 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52732 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
52733 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52734 return resultobj;
52735 fail:
52736 return NULL;
52737 }
52738
52739
52740 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52741 PyObject *resultobj = 0;
52742 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52743 wxIndividualLayoutConstraint *result = 0 ;
52744 void *argp1 = 0 ;
52745 int res1 = 0 ;
52746 PyObject *swig_obj[1] ;
52747
52748 if (!args) SWIG_fail;
52749 swig_obj[0] = args;
52750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52751 if (!SWIG_IsOK(res1)) {
52752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52753 }
52754 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52755 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
52756 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52757 return resultobj;
52758 fail:
52759 return NULL;
52760 }
52761
52762
52763 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52764 PyObject *resultobj = 0;
52765 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52766 wxIndividualLayoutConstraint *result = 0 ;
52767 void *argp1 = 0 ;
52768 int res1 = 0 ;
52769 PyObject *swig_obj[1] ;
52770
52771 if (!args) SWIG_fail;
52772 swig_obj[0] = args;
52773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52774 if (!SWIG_IsOK(res1)) {
52775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52776 }
52777 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52778 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
52779 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52780 return resultobj;
52781 fail:
52782 return NULL;
52783 }
52784
52785
52786 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52787 PyObject *resultobj = 0;
52788 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52789 wxIndividualLayoutConstraint *result = 0 ;
52790 void *argp1 = 0 ;
52791 int res1 = 0 ;
52792 PyObject *swig_obj[1] ;
52793
52794 if (!args) SWIG_fail;
52795 swig_obj[0] = args;
52796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52797 if (!SWIG_IsOK(res1)) {
52798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52799 }
52800 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52801 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
52802 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52803 return resultobj;
52804 fail:
52805 return NULL;
52806 }
52807
52808
52809 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52810 PyObject *resultobj = 0;
52811 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52812 wxIndividualLayoutConstraint *result = 0 ;
52813 void *argp1 = 0 ;
52814 int res1 = 0 ;
52815 PyObject *swig_obj[1] ;
52816
52817 if (!args) SWIG_fail;
52818 swig_obj[0] = args;
52819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52820 if (!SWIG_IsOK(res1)) {
52821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52822 }
52823 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52824 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
52825 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52826 return resultobj;
52827 fail:
52828 return NULL;
52829 }
52830
52831
52832 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52833 PyObject *resultobj = 0;
52834 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52835 wxIndividualLayoutConstraint *result = 0 ;
52836 void *argp1 = 0 ;
52837 int res1 = 0 ;
52838 PyObject *swig_obj[1] ;
52839
52840 if (!args) SWIG_fail;
52841 swig_obj[0] = args;
52842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52843 if (!SWIG_IsOK(res1)) {
52844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52845 }
52846 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52847 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
52848 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52849 return resultobj;
52850 fail:
52851 return NULL;
52852 }
52853
52854
52855 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52856 PyObject *resultobj = 0;
52857 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52858 wxIndividualLayoutConstraint *result = 0 ;
52859 void *argp1 = 0 ;
52860 int res1 = 0 ;
52861 PyObject *swig_obj[1] ;
52862
52863 if (!args) SWIG_fail;
52864 swig_obj[0] = args;
52865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52866 if (!SWIG_IsOK(res1)) {
52867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52868 }
52869 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52870 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
52871 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52872 return resultobj;
52873 fail:
52874 return NULL;
52875 }
52876
52877
52878 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52879 PyObject *resultobj = 0;
52880 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52881 wxIndividualLayoutConstraint *result = 0 ;
52882 void *argp1 = 0 ;
52883 int res1 = 0 ;
52884 PyObject *swig_obj[1] ;
52885
52886 if (!args) SWIG_fail;
52887 swig_obj[0] = args;
52888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52889 if (!SWIG_IsOK(res1)) {
52890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52891 }
52892 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52893 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
52894 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52895 return resultobj;
52896 fail:
52897 return NULL;
52898 }
52899
52900
52901 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52902 PyObject *resultobj = 0;
52903 wxLayoutConstraints *result = 0 ;
52904
52905 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
52906 {
52907 PyThreadState* __tstate = wxPyBeginAllowThreads();
52908 result = (wxLayoutConstraints *)new wxLayoutConstraints();
52909 wxPyEndAllowThreads(__tstate);
52910 if (PyErr_Occurred()) SWIG_fail;
52911 }
52912 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
52913 return resultobj;
52914 fail:
52915 return NULL;
52916 }
52917
52918
52919 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52920 PyObject *resultobj = 0;
52921 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52922 void *argp1 = 0 ;
52923 int res1 = 0 ;
52924 PyObject *swig_obj[1] ;
52925
52926 if (!args) SWIG_fail;
52927 swig_obj[0] = args;
52928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
52929 if (!SWIG_IsOK(res1)) {
52930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52931 }
52932 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52933 {
52934 PyThreadState* __tstate = wxPyBeginAllowThreads();
52935 delete arg1;
52936
52937 wxPyEndAllowThreads(__tstate);
52938 if (PyErr_Occurred()) SWIG_fail;
52939 }
52940 resultobj = SWIG_Py_Void();
52941 return resultobj;
52942 fail:
52943 return NULL;
52944 }
52945
52946
52947 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52948 PyObject *resultobj = 0;
52949 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52950 wxWindow *arg2 = (wxWindow *) 0 ;
52951 int *arg3 = (int *) 0 ;
52952 bool result;
52953 void *argp1 = 0 ;
52954 int res1 = 0 ;
52955 void *argp2 = 0 ;
52956 int res2 = 0 ;
52957 int temp3 ;
52958 int res3 = SWIG_TMPOBJ ;
52959 PyObject * obj0 = 0 ;
52960 PyObject * obj1 = 0 ;
52961 char * kwnames[] = {
52962 (char *) "self",(char *) "win", NULL
52963 };
52964
52965 arg3 = &temp3;
52966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
52967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52968 if (!SWIG_IsOK(res1)) {
52969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52970 }
52971 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52972 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52973 if (!SWIG_IsOK(res2)) {
52974 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
52975 }
52976 arg2 = reinterpret_cast< wxWindow * >(argp2);
52977 {
52978 PyThreadState* __tstate = wxPyBeginAllowThreads();
52979 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
52980 wxPyEndAllowThreads(__tstate);
52981 if (PyErr_Occurred()) SWIG_fail;
52982 }
52983 {
52984 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52985 }
52986 if (SWIG_IsTmpObj(res3)) {
52987 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
52988 } else {
52989 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
52990 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
52991 }
52992 return resultobj;
52993 fail:
52994 return NULL;
52995 }
52996
52997
52998 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52999 PyObject *resultobj = 0;
53000 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53001 bool result;
53002 void *argp1 = 0 ;
53003 int res1 = 0 ;
53004 PyObject *swig_obj[1] ;
53005
53006 if (!args) SWIG_fail;
53007 swig_obj[0] = args;
53008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53009 if (!SWIG_IsOK(res1)) {
53010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
53011 }
53012 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53013 {
53014 PyThreadState* __tstate = wxPyBeginAllowThreads();
53015 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
53016 wxPyEndAllowThreads(__tstate);
53017 if (PyErr_Occurred()) SWIG_fail;
53018 }
53019 {
53020 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53021 }
53022 return resultobj;
53023 fail:
53024 return NULL;
53025 }
53026
53027
53028 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53029 PyObject *obj;
53030 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53031 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
53032 return SWIG_Py_Void();
53033 }
53034
53035 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53036 return SWIG_Python_InitShadowInstance(args);
53037 }
53038
53039 static PyMethodDef SwigMethods[] = {
53040 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
53041 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
53042 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
53043 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
53044 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
53045 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
53046 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
53047 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
53048 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
53049 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
53050 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53051 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53052 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53053 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53054 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
53055 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
53056 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
53057 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53058 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53059 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
53060 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
53061 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
53062 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
53063 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
53064 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
53065 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
53066 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
53067 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
53068 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
53069 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
53070 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
53071 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53072 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
53073 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53074 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53075 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53076 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53077 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53078 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
53079 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
53080 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
53081 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
53082 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
53083 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
53084 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
53085 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
53086 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
53087 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53088 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53089 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53090 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53091 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
53092 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
53093 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53094 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
53095 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
53096 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
53097 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
53098 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
53099 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
53100 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
53101 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
53102 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
53103 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
53104 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
53105 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
53106 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
53107 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53108 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
53109 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
53110 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
53111 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53112 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
53113 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53114 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
53115 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
53116 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
53117 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
53118 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
53119 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
53120 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
53121 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
53122 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
53123 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
53124 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
53125 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
53126 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
53127 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
53128 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
53129 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
53130 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
53131 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
53132 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
53133 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53134 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
53135 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53136 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53137 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
53138 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
53139 { (char *)"Rect_InsideRect", (PyCFunction) _wrap_Rect_InsideRect, METH_VARARGS | METH_KEYWORDS, NULL},
53140 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
53141 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
53142 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
53143 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
53144 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
53145 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
53146 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
53147 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
53148 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
53149 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
53150 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53151 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
53152 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
53153 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
53154 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
53155 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
53156 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
53157 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53158 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
53159 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
53160 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
53161 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
53162 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
53163 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
53164 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
53165 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
53166 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
53167 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
53168 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
53169 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
53170 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
53171 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
53172 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
53173 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53174 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53175 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
53176 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
53177 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
53178 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
53179 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53180 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
53181 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
53182 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
53183 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
53184 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
53185 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
53186 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
53187 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
53188 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
53189 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
53190 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
53191 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
53192 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
53193 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
53194 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
53195 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
53196 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
53197 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
53198 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
53199 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
53200 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
53201 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
53202 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
53203 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
53204 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
53205 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
53206 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
53207 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
53208 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
53209 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
53210 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
53211 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
53212 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
53213 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
53214 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
53215 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
53216 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
53217 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
53218 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53219 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53220 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53221 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53222 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
53223 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
53224 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
53225 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
53226 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
53227 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
53228 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
53229 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
53230 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
53231 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
53232 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
53233 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
53234 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53235 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53236 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
53237 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53238 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
53239 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
53240 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
53241 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
53242 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
53243 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
53244 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53245 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53246 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
53247 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
53248 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
53249 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53250 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53251 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53252 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
53253 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
53254 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
53255 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
53256 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53257 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
53258 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
53259 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
53260 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53261 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53262 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53263 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
53264 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
53265 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
53266 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
53267 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
53268 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
53269 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
53270 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
53271 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53272 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53273 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
53274 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
53275 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
53276 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
53277 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
53278 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53279 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
53280 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
53281 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
53282 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
53283 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
53284 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
53285 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53286 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
53287 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
53288 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
53289 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
53290 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
53291 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
53292 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
53293 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
53294 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
53295 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
53296 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
53297 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
53298 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
53299 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
53300 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
53301 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
53302 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
53303 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
53304 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
53305 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
53306 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
53307 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
53308 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
53309 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
53310 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
53311 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
53312 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
53313 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53314 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
53315 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53316 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53317 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
53318 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
53319 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
53320 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
53321 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
53322 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53323 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
53324 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
53325 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
53326 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
53327 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53328 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53329 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
53330 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
53331 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
53332 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
53333 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
53334 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53335 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
53336 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
53337 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
53338 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
53339 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
53340 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
53341 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
53342 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53343 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53344 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
53345 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
53346 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
53347 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
53348 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
53349 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
53350 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
53351 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
53352 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
53353 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
53354 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
53355 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
53356 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53357 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
53358 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
53359 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
53360 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53361 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
53362 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
53363 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
53364 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
53365 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
53366 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
53367 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
53368 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
53369 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
53370 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
53371 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53372 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
53373 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
53374 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
53375 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
53376 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
53377 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
53378 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
53379 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
53380 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
53381 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53382 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53383 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53384 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
53385 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
53386 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53387 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53388 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
53389 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
53390 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53391 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
53392 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
53393 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53394 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
53395 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
53396 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
53397 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
53398 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
53399 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
53400 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
53401 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
53402 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
53403 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
53404 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
53405 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
53406 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
53407 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
53408 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
53409 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
53410 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
53411 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
53412 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
53413 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
53414 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
53415 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
53416 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
53417 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
53418 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
53419 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
53420 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
53421 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
53422 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
53423 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
53424 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
53425 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
53426 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
53427 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
53428 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
53429 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
53430 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
53431 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
53432 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53433 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53434 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
53435 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53436 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53437 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53438 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
53439 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
53440 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
53441 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53442 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
53443 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
53444 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
53445 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
53446 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
53447 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
53448 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
53449 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
53450 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
53451 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
53452 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
53453 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53454 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
53455 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
53456 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
53457 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
53458 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
53459 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
53460 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
53461 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
53462 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
53463 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
53464 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
53465 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
53466 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
53467 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
53468 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
53469 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
53470 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53471 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
53472 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53473 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
53474 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
53475 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
53476 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
53477 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
53478 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
53479 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
53480 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
53481 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53482 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
53483 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
53484 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
53485 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53486 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
53487 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
53488 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
53489 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
53490 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
53491 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53492 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
53493 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
53494 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53495 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53496 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
53497 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
53498 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53499 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
53500 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
53501 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53502 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53503 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
53504 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
53505 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53506 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
53507 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
53508 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
53509 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
53510 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
53511 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
53512 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
53513 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
53514 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
53515 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
53516 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
53517 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
53518 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
53519 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
53520 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
53521 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
53522 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
53523 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
53524 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
53525 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
53526 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
53527 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
53528 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
53529 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
53530 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
53531 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
53532 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
53533 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
53534 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
53535 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
53536 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53537 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
53538 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
53539 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
53540 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
53541 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
53542 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
53543 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
53544 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
53545 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
53546 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
53547 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
53548 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
53549 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
53550 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
53551 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
53552 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
53553 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
53554 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
53555 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
53556 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
53557 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
53558 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
53559 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
53560 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
53561 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
53562 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
53563 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
53564 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
53565 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
53566 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
53567 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
53568 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
53569 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53570 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
53571 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
53572 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53573 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
53574 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
53575 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
53576 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
53577 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53578 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
53579 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
53580 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
53581 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
53582 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
53583 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
53584 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
53585 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
53586 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
53587 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
53588 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
53589 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
53590 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
53591 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
53592 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
53593 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
53594 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
53595 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
53596 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
53597 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
53598 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
53599 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
53600 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
53601 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
53602 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
53603 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
53604 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
53605 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
53606 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
53607 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
53608 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
53609 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
53610 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
53611 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
53612 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
53613 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
53614 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
53615 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
53616 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53617 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
53618 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
53619 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53620 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53621 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
53622 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
53623 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
53624 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
53625 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
53626 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
53627 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53628 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
53629 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
53630 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53631 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53632 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
53633 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
53634 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53635 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
53636 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
53637 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53638 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
53639 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
53640 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53641 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
53642 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
53643 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
53644 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53645 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
53646 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53647 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
53648 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
53649 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53650 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
53651 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
53652 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
53653 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53654 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
53655 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
53656 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
53657 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53658 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
53659 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
53660 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53661 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
53662 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
53663 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
53664 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
53665 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
53666 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53667 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
53668 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
53669 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
53670 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
53671 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
53672 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
53673 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
53674 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
53675 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53676 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
53677 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
53678 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
53679 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
53680 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53681 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
53682 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
53683 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
53684 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53685 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
53686 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
53687 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
53688 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
53689 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
53690 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
53691 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53692 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
53693 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
53694 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
53695 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
53696 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
53697 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
53698 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
53699 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
53700 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53701 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53702 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53703 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53704 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
53705 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
53706 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
53707 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
53708 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53709 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
53710 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
53711 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
53712 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
53713 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
53714 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
53715 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53716 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
53717 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
53718 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
53719 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53720 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
53721 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
53722 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
53723 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
53724 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
53725 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53726 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53727 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
53728 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
53729 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
53730 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53731 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
53732 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
53733 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
53734 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
53735 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
53736 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
53737 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53738 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
53739 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
53740 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
53741 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
53742 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
53743 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
53744 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
53745 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
53746 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
53747 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53748 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
53749 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
53750 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
53751 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53752 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
53753 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
53754 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
53755 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53756 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
53757 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53758 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
53759 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
53760 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
53761 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
53762 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
53763 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53764 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
53765 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
53766 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
53767 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
53768 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53769 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
53770 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
53771 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53772 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
53773 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53774 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
53775 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
53776 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
53777 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53778 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
53779 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53780 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
53781 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
53782 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
53783 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53784 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
53785 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
53786 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
53787 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
53788 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
53789 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
53790 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53791 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
53792 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
53793 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
53794 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
53795 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
53796 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
53797 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
53798 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
53799 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
53800 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
53801 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
53802 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
53803 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
53804 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
53805 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
53806 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
53807 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
53808 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
53809 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
53810 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53811 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
53812 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
53813 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
53814 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
53815 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
53816 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
53817 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
53818 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
53819 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
53820 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
53821 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
53822 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
53823 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
53824 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
53825 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
53826 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53827 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53828 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53829 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
53830 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
53831 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
53832 { (char *)"PyApp_DisplayAvailable", (PyCFunction)_wrap_PyApp_DisplayAvailable, METH_NOARGS, NULL},
53833 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
53834 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
53835 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
53836 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
53837 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
53838 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
53839 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
53840 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53841 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
53842 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
53843 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
53844 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
53845 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
53846 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
53847 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
53848 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
53849 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
53850 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
53851 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
53852 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
53853 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
53854 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
53855 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
53856 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
53857 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
53858 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
53859 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
53860 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
53861 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
53862 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53863 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
53864 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
53865 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
53866 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
53867 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
53868 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53869 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
53870 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
53871 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
53872 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
53873 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
53874 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
53875 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
53876 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
53877 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
53878 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
53879 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
53880 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
53881 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
53882 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
53883 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
53884 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
53885 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
53886 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53887 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
53888 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
53889 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
53890 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
53891 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53892 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
53893 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53894 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
53895 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
53896 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
53897 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53898 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
53899 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
53900 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53901 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53902 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53903 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
53904 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53905 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53906 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
53907 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
53908 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
53909 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
53910 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
53911 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
53912 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53913 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
53914 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
53915 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
53916 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
53917 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
53918 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
53919 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
53920 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
53921 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
53922 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
53923 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
53924 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
53925 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
53926 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
53927 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
53928 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
53929 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
53930 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
53931 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
53932 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
53933 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
53934 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
53935 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
53936 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53937 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53938 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53939 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53940 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
53941 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
53942 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53943 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
53944 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
53945 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
53946 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
53947 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
53948 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
53949 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53950 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
53951 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
53952 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
53953 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53954 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
53955 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53956 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
53957 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
53958 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
53959 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53960 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
53961 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53962 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
53963 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53964 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
53965 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
53966 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53967 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
53968 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
53969 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
53970 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
53971 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
53972 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
53973 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
53974 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53975 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53976 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
53977 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
53978 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
53979 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
53980 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
53981 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
53982 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
53983 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
53984 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53985 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53986 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
53987 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53988 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53989 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53990 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53991 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
53992 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
53993 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
53994 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
53995 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
53996 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
53997 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53998 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
53999 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
54000 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
54001 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
54002 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
54003 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
54004 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
54005 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
54006 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
54007 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
54008 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
54009 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
54010 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
54011 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
54012 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
54013 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
54014 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
54015 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
54016 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
54017 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
54018 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
54019 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
54020 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
54021 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
54022 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54023 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
54024 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
54025 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
54026 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54027 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54028 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54029 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54030 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
54031 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
54032 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
54033 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
54034 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
54035 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
54036 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
54037 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
54038 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
54039 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
54040 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
54041 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
54042 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
54043 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
54044 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
54045 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
54046 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
54047 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
54048 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
54049 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
54050 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
54051 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
54052 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
54053 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
54054 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
54055 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
54056 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
54057 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54058 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
54059 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
54060 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
54061 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
54062 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
54063 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
54064 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
54065 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
54066 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
54067 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
54068 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54069 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
54070 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
54071 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
54072 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
54073 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
54074 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
54075 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
54076 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
54077 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54078 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
54079 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
54080 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
54081 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
54082 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
54083 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
54084 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
54085 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
54086 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
54087 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
54088 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
54089 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
54090 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54091 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
54092 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
54093 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54094 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
54095 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
54096 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
54097 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
54098 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
54099 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
54100 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
54101 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
54102 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
54103 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54104 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
54105 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
54106 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
54107 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
54108 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
54109 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
54110 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
54111 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
54112 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54113 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
54114 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
54115 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
54116 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
54117 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
54118 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54119 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
54120 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
54121 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
54122 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54123 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
54124 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54125 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54126 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54127 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54128 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
54129 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
54130 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
54131 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
54132 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54133 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
54134 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54135 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54136 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54137 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
54138 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
54139 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54140 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54141 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54142 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54143 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
54144 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
54145 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
54146 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
54147 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
54148 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
54149 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
54150 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
54151 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
54152 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
54153 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54154 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54155 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54156 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54157 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
54158 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54159 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54160 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54161 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54162 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
54163 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
54164 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54165 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
54166 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54167 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
54168 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
54169 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
54170 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
54171 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
54172 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
54173 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
54174 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
54175 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
54176 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
54177 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
54178 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
54179 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54180 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54181 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
54182 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54183 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
54184 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54185 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
54186 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
54187 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
54188 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
54189 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
54190 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
54191 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54192 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54193 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54194 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
54195 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54196 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54197 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54198 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54199 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54200 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
54201 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
54202 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
54203 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
54204 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
54205 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54206 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
54207 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
54208 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
54209 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
54210 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
54211 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
54212 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54213 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
54214 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
54215 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
54216 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
54217 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
54218 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
54219 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
54220 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
54221 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
54222 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
54223 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
54224 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
54225 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54226 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
54227 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54228 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
54229 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54230 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
54231 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
54232 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
54233 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
54234 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
54235 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
54236 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54237 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
54238 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
54239 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
54240 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
54241 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
54242 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54243 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
54244 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
54245 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54246 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
54247 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
54248 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
54249 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
54250 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
54251 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
54252 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
54253 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
54254 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
54255 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
54256 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
54257 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54258 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
54259 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
54260 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
54261 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
54262 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
54263 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
54264 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
54265 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54266 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
54267 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54268 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
54269 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
54270 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54271 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54272 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
54273 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
54274 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
54275 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
54276 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
54277 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
54278 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
54279 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
54280 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
54281 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
54282 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
54283 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
54284 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
54285 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
54286 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
54287 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54288 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54289 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54290 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
54291 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
54292 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
54293 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
54294 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
54295 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
54296 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
54297 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
54298 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
54299 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
54300 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
54301 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
54302 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
54303 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
54304 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
54305 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
54306 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
54307 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
54308 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
54309 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
54310 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
54311 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
54312 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
54313 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54314 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
54315 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54316 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
54317 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54318 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54319 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
54320 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
54321 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
54322 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
54323 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
54324 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
54325 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
54326 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54327 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
54328 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54329 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
54330 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54331 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
54332 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
54333 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54334 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
54335 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
54336 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
54337 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
54338 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54339 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
54340 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
54341 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
54342 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
54343 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
54344 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
54345 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
54346 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
54347 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54348 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54349 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
54350 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
54351 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
54352 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54353 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
54354 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
54355 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
54356 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
54357 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54358 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
54359 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
54360 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54361 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
54362 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54363 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
54364 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
54365 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54366 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
54367 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
54368 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
54369 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54370 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
54371 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
54372 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
54373 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
54374 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
54375 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
54376 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
54377 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
54378 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
54379 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
54380 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54381 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
54382 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
54383 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
54384 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
54385 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54386 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
54387 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
54388 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
54389 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
54390 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
54391 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
54392 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
54393 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
54394 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
54395 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
54396 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
54397 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
54398 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
54399 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
54400 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
54401 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
54402 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
54403 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
54404 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
54405 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
54406 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54407 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
54408 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
54409 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
54410 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
54411 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
54412 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54413 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54414 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54415 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
54416 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
54417 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
54418 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
54419 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
54420 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
54421 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
54422 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
54423 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
54424 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54425 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54426 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54427 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
54428 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
54429 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
54430 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
54431 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
54432 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54433 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54434 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54435 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
54436 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
54437 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
54438 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
54439 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
54440 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
54441 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
54442 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
54443 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54444 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
54445 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
54446 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54447 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
54448 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
54449 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
54450 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
54451 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
54452 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
54453 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
54454 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
54455 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
54456 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
54457 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54458 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54459 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
54460 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
54461 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
54462 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
54463 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54464 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
54465 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
54466 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
54467 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
54468 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
54469 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
54470 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
54471 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
54472 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
54473 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
54474 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
54475 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
54476 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
54477 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
54478 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
54479 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
54480 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
54481 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
54482 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
54483 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
54484 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
54485 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
54486 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
54487 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
54488 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
54489 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
54490 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
54491 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
54492 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
54493 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
54494 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
54495 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
54496 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
54497 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
54498 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
54499 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
54500 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
54501 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
54502 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
54503 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
54504 { NULL, NULL, 0, NULL }
54505 };
54506
54507
54508 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
54509
54510 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
54511 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
54512 }
54513 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
54514 return (void *)((wxSizer *) ((wxBoxSizer *) x));
54515 }
54516 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
54517 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
54518 }
54519 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
54520 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54521 }
54522 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
54523 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54524 }
54525 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
54526 return (void *)((wxSizer *) ((wxGridSizer *) x));
54527 }
54528 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
54529 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
54530 }
54531 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
54532 return (void *)((wxSizer *) ((wxPySizer *) x));
54533 }
54534 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
54535 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
54536 }
54537 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
54538 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54539 }
54540 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
54541 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
54542 }
54543 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
54544 return (void *)((wxEvent *) ((wxMenuEvent *) x));
54545 }
54546 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
54547 return (void *)((wxEvent *) ((wxCloseEvent *) x));
54548 }
54549 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
54550 return (void *)((wxEvent *) ((wxMouseEvent *) x));
54551 }
54552 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
54553 return (void *)((wxEvent *) ((wxEraseEvent *) x));
54554 }
54555 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
54556 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
54557 }
54558 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
54559 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
54560 }
54561 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
54562 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
54563 }
54564 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
54565 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
54566 }
54567 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
54568 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
54569 }
54570 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
54571 return (void *)((wxEvent *) ((wxPyEvent *) x));
54572 }
54573 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
54574 return (void *)((wxEvent *) ((wxIdleEvent *) x));
54575 }
54576 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
54577 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
54578 }
54579 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
54580 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
54581 }
54582 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
54583 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
54584 }
54585 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
54586 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
54587 }
54588 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
54589 return (void *)((wxEvent *) ((wxActivateEvent *) x));
54590 }
54591 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
54592 return (void *)((wxEvent *) ((wxSizeEvent *) x));
54593 }
54594 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
54595 return (void *)((wxEvent *) ((wxMoveEvent *) x));
54596 }
54597 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
54598 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
54599 }
54600 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
54601 return (void *)((wxEvent *) ((wxPaintEvent *) x));
54602 }
54603 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
54604 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
54605 }
54606 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
54607 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
54608 }
54609 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
54610 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
54611 }
54612 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
54613 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
54614 }
54615 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
54616 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
54617 }
54618 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
54619 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54620 }
54621 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
54622 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
54623 }
54624 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
54625 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
54626 }
54627 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
54628 return (void *)((wxEvent *) ((wxFocusEvent *) x));
54629 }
54630 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
54631 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
54632 }
54633 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
54634 return (void *)((wxEvent *) ((wxShowEvent *) x));
54635 }
54636 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
54637 return (void *)((wxEvent *) ((wxCommandEvent *) x));
54638 }
54639 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
54640 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
54641 }
54642 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
54643 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54644 }
54645 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
54646 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
54647 }
54648 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
54649 return (void *)((wxEvent *) ((wxKeyEvent *) x));
54650 }
54651 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
54652 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
54653 }
54654 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
54655 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
54656 }
54657 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
54658 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
54659 }
54660 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
54661 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
54662 }
54663 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
54664 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
54665 }
54666 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
54667 return (void *)((wxControl *) ((wxControlWithItems *) x));
54668 }
54669 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
54670 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
54671 }
54672 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
54673 return (void *)((wxEvtHandler *) ((wxWindow *) x));
54674 }
54675 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
54676 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54677 }
54678 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
54679 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
54680 }
54681 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
54682 return (void *)((wxEvtHandler *) ((wxValidator *) x));
54683 }
54684 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
54685 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
54686 }
54687 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
54688 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
54689 }
54690 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
54691 return (void *)((wxEvtHandler *) ((wxMenu *) x));
54692 }
54693 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
54694 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
54695 }
54696 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
54697 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
54698 }
54699 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
54700 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
54701 }
54702 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
54703 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
54704 }
54705 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
54706 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
54707 }
54708 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
54709 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54710 }
54711 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
54712 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
54713 }
54714 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
54715 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
54716 }
54717 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
54718 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
54719 }
54720 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
54721 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54722 }
54723 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
54724 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54725 }
54726 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
54727 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
54728 }
54729 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
54730 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
54731 }
54732 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
54733 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
54734 }
54735 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
54736 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
54737 }
54738 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
54739 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
54740 }
54741 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
54742 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
54743 }
54744 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
54745 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
54746 }
54747 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
54748 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
54749 }
54750 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
54751 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
54752 }
54753 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
54754 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
54755 }
54756 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
54757 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
54758 }
54759 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
54760 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
54761 }
54762 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
54763 return (void *)((wxObject *) ((wxSizerItem *) x));
54764 }
54765 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
54766 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
54767 }
54768 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
54769 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
54770 }
54771 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
54772 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
54773 }
54774 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
54775 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
54776 }
54777 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
54778 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
54779 }
54780 static void *_p_wxSizerTo_p_wxObject(void *x) {
54781 return (void *)((wxObject *) ((wxSizer *) x));
54782 }
54783 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
54784 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54785 }
54786 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
54787 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
54788 }
54789 static void *_p_wxEventTo_p_wxObject(void *x) {
54790 return (void *)((wxObject *) ((wxEvent *) x));
54791 }
54792 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
54793 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
54794 }
54795 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
54796 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
54797 }
54798 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
54799 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
54800 }
54801 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
54802 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
54803 }
54804 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
54805 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
54806 }
54807 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
54808 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
54809 }
54810 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
54811 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
54812 }
54813 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
54814 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
54815 }
54816 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
54817 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54818 }
54819 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
54820 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
54821 }
54822 static void *_p_wxControlTo_p_wxObject(void *x) {
54823 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
54824 }
54825 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
54826 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
54827 }
54828 static void *_p_wxFSFileTo_p_wxObject(void *x) {
54829 return (void *)((wxObject *) ((wxFSFile *) x));
54830 }
54831 static void *_p_wxPySizerTo_p_wxObject(void *x) {
54832 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
54833 }
54834 static void *_p_wxPyEventTo_p_wxObject(void *x) {
54835 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
54836 }
54837 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
54838 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
54839 }
54840 static void *_p_wxShowEventTo_p_wxObject(void *x) {
54841 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
54842 }
54843 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
54844 return (void *)((wxObject *) ((wxMenuItem *) x));
54845 }
54846 static void *_p_wxDateEventTo_p_wxObject(void *x) {
54847 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
54848 }
54849 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
54850 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
54851 }
54852 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
54853 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
54854 }
54855 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
54856 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
54857 }
54858 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
54859 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
54860 }
54861 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
54862 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
54863 }
54864 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
54865 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
54866 }
54867 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
54868 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
54869 }
54870 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
54871 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
54872 }
54873 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
54874 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
54875 }
54876 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
54877 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
54878 }
54879 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
54880 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
54881 }
54882 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
54883 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
54884 }
54885 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
54886 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
54887 }
54888 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
54889 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54890 }
54891 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
54892 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54893 }
54894 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
54895 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
54896 }
54897 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
54898 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
54899 }
54900 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
54901 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
54902 }
54903 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
54904 return (void *)((wxObject *) ((wxImageHandler *) x));
54905 }
54906 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
54907 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
54908 }
54909 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
54910 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
54911 }
54912 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
54913 return (void *)((wxObject *) ((wxEvtHandler *) x));
54914 }
54915 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
54916 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
54917 }
54918 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
54919 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54920 }
54921 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
54922 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
54923 }
54924 static void *_p_wxImageTo_p_wxObject(void *x) {
54925 return (void *)((wxObject *) ((wxImage *) x));
54926 }
54927 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
54928 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
54929 }
54930 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
54931 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54932 }
54933 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
54934 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
54935 }
54936 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
54937 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
54938 }
54939 static void *_p_wxWindowTo_p_wxObject(void *x) {
54940 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
54941 }
54942 static void *_p_wxMenuTo_p_wxObject(void *x) {
54943 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
54944 }
54945 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
54946 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
54947 }
54948 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
54949 return (void *)((wxObject *) ((wxFileSystem *) x));
54950 }
54951 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
54952 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
54953 }
54954 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
54955 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
54956 }
54957 static void *_p_wxPyAppTo_p_wxObject(void *x) {
54958 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
54959 }
54960 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
54961 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
54962 }
54963 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
54964 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
54965 }
54966 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
54967 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
54968 }
54969 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
54970 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
54971 }
54972 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
54973 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
54974 }
54975 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
54976 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
54977 }
54978 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
54979 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
54980 }
54981 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
54982 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
54983 }
54984 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
54985 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54986 }
54987 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
54988 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
54989 }
54990 static void *_p_wxValidatorTo_p_wxObject(void *x) {
54991 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
54992 }
54993 static void *_p_wxControlTo_p_wxWindow(void *x) {
54994 return (void *)((wxWindow *) ((wxControl *) x));
54995 }
54996 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
54997 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
54998 }
54999 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
55000 return (void *)((wxWindow *) ((wxMenuBar *) x));
55001 }
55002 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
55003 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
55004 }
55005 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
55006 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
55007 }
55008 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
55009 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
55010 }
55011 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
55012 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
55013 }
55014 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
55015 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
55016 }
55017 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
55018 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
55019 }
55020 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
55021 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
55022 }
55023 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
55024 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
55025 }
55026 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
55027 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
55028 }
55029 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
55030 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
55031 }
55032 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
55033 return (void *)((wxValidator *) ((wxPyValidator *) x));
55034 }
55035 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
55036 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
55037 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};
55038 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
55039 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
55040 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
55041 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
55042 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
55043 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
55044 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
55045 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
55046 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
55047 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
55048 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
55049 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
55050 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
55051 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
55052 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
55053 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
55054 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
55055 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
55056 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
55057 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
55058 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
55059 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
55060 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
55061 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
55062 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
55063 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
55064 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
55065 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
55066 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
55067 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
55068 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
55069 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
55070 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
55071 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
55072 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
55073 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
55074 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
55075 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
55076 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
55077 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
55078 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
55079 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
55080 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
55081 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
55082 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
55083 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
55084 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
55085 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
55086 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
55087 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
55088 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
55089 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
55090 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
55091 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
55092 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
55093 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
55094 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
55095 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
55096 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
55097 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
55098 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
55099 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
55100 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
55101 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
55102 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
55103 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
55104 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
55105 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
55106 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
55107 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
55108 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
55109 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
55110 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
55111 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
55112 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
55113 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
55114 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
55115 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
55116 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
55117 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
55118 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
55119 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
55120 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
55121 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
55122 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
55123 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
55124 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
55125 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
55126 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
55127 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
55128 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
55129 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
55130 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
55131 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
55132 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
55133 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
55134 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
55135 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
55136 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
55137 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
55138 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
55139 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
55140 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
55141 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
55142 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
55143 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
55144 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
55145 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
55146 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
55147 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
55148 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
55149 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
55150 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
55151 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
55152 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
55153 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
55154 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
55155 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
55156 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
55157 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
55158 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
55159 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
55160 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
55161 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
55162 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
55163 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
55164 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
55165 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
55166 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
55167
55168 static swig_type_info *swig_type_initial[] = {
55169 &_swigt__p_buffer,
55170 &_swigt__p_char,
55171 &_swigt__p_form_ops_t,
55172 &_swigt__p_int,
55173 &_swigt__p_long,
55174 &_swigt__p_unsigned_char,
55175 &_swigt__p_unsigned_int,
55176 &_swigt__p_unsigned_long,
55177 &_swigt__p_wxANIHandler,
55178 &_swigt__p_wxAcceleratorEntry,
55179 &_swigt__p_wxAcceleratorTable,
55180 &_swigt__p_wxActivateEvent,
55181 &_swigt__p_wxAppTraits,
55182 &_swigt__p_wxArrayString,
55183 &_swigt__p_wxBMPHandler,
55184 &_swigt__p_wxBitmap,
55185 &_swigt__p_wxBoxSizer,
55186 &_swigt__p_wxButton,
55187 &_swigt__p_wxCURHandler,
55188 &_swigt__p_wxCaret,
55189 &_swigt__p_wxChildFocusEvent,
55190 &_swigt__p_wxClipboardTextEvent,
55191 &_swigt__p_wxCloseEvent,
55192 &_swigt__p_wxColour,
55193 &_swigt__p_wxCommandEvent,
55194 &_swigt__p_wxContextMenuEvent,
55195 &_swigt__p_wxControl,
55196 &_swigt__p_wxControlWithItems,
55197 &_swigt__p_wxCursor,
55198 &_swigt__p_wxDC,
55199 &_swigt__p_wxDateEvent,
55200 &_swigt__p_wxDateTime,
55201 &_swigt__p_wxDisplayChangedEvent,
55202 &_swigt__p_wxDropFilesEvent,
55203 &_swigt__p_wxDuplexMode,
55204 &_swigt__p_wxEraseEvent,
55205 &_swigt__p_wxEvent,
55206 &_swigt__p_wxEventLoop,
55207 &_swigt__p_wxEventLoopActivator,
55208 &_swigt__p_wxEvtHandler,
55209 &_swigt__p_wxFSFile,
55210 &_swigt__p_wxFileSystem,
55211 &_swigt__p_wxFileSystemHandler,
55212 &_swigt__p_wxFlexGridSizer,
55213 &_swigt__p_wxFocusEvent,
55214 &_swigt__p_wxFont,
55215 &_swigt__p_wxFrame,
55216 &_swigt__p_wxGBPosition,
55217 &_swigt__p_wxGBSizerItem,
55218 &_swigt__p_wxGBSpan,
55219 &_swigt__p_wxGIFHandler,
55220 &_swigt__p_wxGridBagSizer,
55221 &_swigt__p_wxGridSizer,
55222 &_swigt__p_wxHelpEvent__Origin,
55223 &_swigt__p_wxICOHandler,
55224 &_swigt__p_wxIconizeEvent,
55225 &_swigt__p_wxIdleEvent,
55226 &_swigt__p_wxImage,
55227 &_swigt__p_wxImageHandler,
55228 &_swigt__p_wxImageHistogram,
55229 &_swigt__p_wxImage_HSVValue,
55230 &_swigt__p_wxImage_RGBValue,
55231 &_swigt__p_wxIndividualLayoutConstraint,
55232 &_swigt__p_wxInitDialogEvent,
55233 &_swigt__p_wxInputStream,
55234 &_swigt__p_wxInternetFSHandler,
55235 &_swigt__p_wxItemContainer,
55236 &_swigt__p_wxJPEGHandler,
55237 &_swigt__p_wxKeyEvent,
55238 &_swigt__p_wxLayoutConstraints,
55239 &_swigt__p_wxMaximizeEvent,
55240 &_swigt__p_wxMemoryFSHandler,
55241 &_swigt__p_wxMenu,
55242 &_swigt__p_wxMenuBar,
55243 &_swigt__p_wxMenuBarBase,
55244 &_swigt__p_wxMenuEvent,
55245 &_swigt__p_wxMenuItem,
55246 &_swigt__p_wxMouseCaptureChangedEvent,
55247 &_swigt__p_wxMouseCaptureLostEvent,
55248 &_swigt__p_wxMouseEvent,
55249 &_swigt__p_wxMoveEvent,
55250 &_swigt__p_wxNavigationKeyEvent,
55251 &_swigt__p_wxNcPaintEvent,
55252 &_swigt__p_wxNotifyEvent,
55253 &_swigt__p_wxObject,
55254 &_swigt__p_wxOutputStream,
55255 &_swigt__p_wxPCXHandler,
55256 &_swigt__p_wxPNGHandler,
55257 &_swigt__p_wxPNMHandler,
55258 &_swigt__p_wxPaintEvent,
55259 &_swigt__p_wxPaletteChangedEvent,
55260 &_swigt__p_wxPaperSize,
55261 &_swigt__p_wxPoint,
55262 &_swigt__p_wxPoint2D,
55263 &_swigt__p_wxPropagateOnce,
55264 &_swigt__p_wxPropagationDisabler,
55265 &_swigt__p_wxPyApp,
55266 &_swigt__p_wxPyCommandEvent,
55267 &_swigt__p_wxPyDropTarget,
55268 &_swigt__p_wxPyEvent,
55269 &_swigt__p_wxPyFileSystemHandler,
55270 &_swigt__p_wxPyImageHandler,
55271 &_swigt__p_wxPyInputStream,
55272 &_swigt__p_wxPySizer,
55273 &_swigt__p_wxPyValidator,
55274 &_swigt__p_wxQuantize,
55275 &_swigt__p_wxQueryNewPaletteEvent,
55276 &_swigt__p_wxRealPoint,
55277 &_swigt__p_wxRect,
55278 &_swigt__p_wxRegion,
55279 &_swigt__p_wxScrollEvent,
55280 &_swigt__p_wxScrollWinEvent,
55281 &_swigt__p_wxSetCursorEvent,
55282 &_swigt__p_wxShowEvent,
55283 &_swigt__p_wxSize,
55284 &_swigt__p_wxSizeEvent,
55285 &_swigt__p_wxSizer,
55286 &_swigt__p_wxSizerItem,
55287 &_swigt__p_wxStaticBox,
55288 &_swigt__p_wxStaticBoxSizer,
55289 &_swigt__p_wxStdDialogButtonSizer,
55290 &_swigt__p_wxSysColourChangedEvent,
55291 &_swigt__p_wxTIFFHandler,
55292 &_swigt__p_wxToolTip,
55293 &_swigt__p_wxUpdateUIEvent,
55294 &_swigt__p_wxValidator,
55295 &_swigt__p_wxVisualAttributes,
55296 &_swigt__p_wxWindow,
55297 &_swigt__p_wxWindowCreateEvent,
55298 &_swigt__p_wxWindowDestroyEvent,
55299 &_swigt__p_wxXPMHandler,
55300 &_swigt__p_wxZipFSHandler,
55301 };
55302
55303 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
55304 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
55305 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
55306 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
55307 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
55308 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
55309 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
55310 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
55311 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
55312 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
55313 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
55314 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
55315 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
55316 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
55317 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}};
55318 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
55319 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}};
55320 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
55321 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}};
55322 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
55323 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
55324 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
55325 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
55326 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
55327 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}};
55328 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
55329 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}};
55330 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
55331 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
55332 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
55333 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
55334 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
55335 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55336 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
55337 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
55338 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
55339 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}};
55340 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
55341 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
55342 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}};
55343 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
55344 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
55345 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}};
55346 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}};
55347 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
55348 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
55349 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
55350 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
55351 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
55352 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
55353 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
55354 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
55355 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}};
55356 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
55357 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}};
55358 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55359 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
55360 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
55361 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}};
55362 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
55363 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
55364 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
55365 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
55366 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
55367 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
55368 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55369 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}};
55370 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
55371 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
55372 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
55373 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55374 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55375 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
55376 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
55377 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
55378 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
55379 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
55380 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55381 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
55382 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
55383 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
55384 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
55385 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
55386 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
55387 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}};
55388 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
55389 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
55390 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
55391 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
55392 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
55393 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55394 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
55395 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
55396 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
55397 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
55398 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
55399 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
55400 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
55401 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
55402 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
55403 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
55404 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
55405 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
55406 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
55407 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
55408 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
55409 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
55410 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
55411 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
55412 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
55413 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
55414 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
55415 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
55416 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
55417 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
55418 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55419 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}};
55420 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}};
55421 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
55422 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
55423 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
55424 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55425 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
55426 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
55427 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
55428 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}};
55429 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
55430 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}};
55431 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
55432 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
55433 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
55434 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55435
55436 static swig_cast_info *swig_cast_initial[] = {
55437 _swigc__p_buffer,
55438 _swigc__p_char,
55439 _swigc__p_form_ops_t,
55440 _swigc__p_int,
55441 _swigc__p_long,
55442 _swigc__p_unsigned_char,
55443 _swigc__p_unsigned_int,
55444 _swigc__p_unsigned_long,
55445 _swigc__p_wxANIHandler,
55446 _swigc__p_wxAcceleratorEntry,
55447 _swigc__p_wxAcceleratorTable,
55448 _swigc__p_wxActivateEvent,
55449 _swigc__p_wxAppTraits,
55450 _swigc__p_wxArrayString,
55451 _swigc__p_wxBMPHandler,
55452 _swigc__p_wxBitmap,
55453 _swigc__p_wxBoxSizer,
55454 _swigc__p_wxButton,
55455 _swigc__p_wxCURHandler,
55456 _swigc__p_wxCaret,
55457 _swigc__p_wxChildFocusEvent,
55458 _swigc__p_wxClipboardTextEvent,
55459 _swigc__p_wxCloseEvent,
55460 _swigc__p_wxColour,
55461 _swigc__p_wxCommandEvent,
55462 _swigc__p_wxContextMenuEvent,
55463 _swigc__p_wxControl,
55464 _swigc__p_wxControlWithItems,
55465 _swigc__p_wxCursor,
55466 _swigc__p_wxDC,
55467 _swigc__p_wxDateEvent,
55468 _swigc__p_wxDateTime,
55469 _swigc__p_wxDisplayChangedEvent,
55470 _swigc__p_wxDropFilesEvent,
55471 _swigc__p_wxDuplexMode,
55472 _swigc__p_wxEraseEvent,
55473 _swigc__p_wxEvent,
55474 _swigc__p_wxEventLoop,
55475 _swigc__p_wxEventLoopActivator,
55476 _swigc__p_wxEvtHandler,
55477 _swigc__p_wxFSFile,
55478 _swigc__p_wxFileSystem,
55479 _swigc__p_wxFileSystemHandler,
55480 _swigc__p_wxFlexGridSizer,
55481 _swigc__p_wxFocusEvent,
55482 _swigc__p_wxFont,
55483 _swigc__p_wxFrame,
55484 _swigc__p_wxGBPosition,
55485 _swigc__p_wxGBSizerItem,
55486 _swigc__p_wxGBSpan,
55487 _swigc__p_wxGIFHandler,
55488 _swigc__p_wxGridBagSizer,
55489 _swigc__p_wxGridSizer,
55490 _swigc__p_wxHelpEvent__Origin,
55491 _swigc__p_wxICOHandler,
55492 _swigc__p_wxIconizeEvent,
55493 _swigc__p_wxIdleEvent,
55494 _swigc__p_wxImage,
55495 _swigc__p_wxImageHandler,
55496 _swigc__p_wxImageHistogram,
55497 _swigc__p_wxImage_HSVValue,
55498 _swigc__p_wxImage_RGBValue,
55499 _swigc__p_wxIndividualLayoutConstraint,
55500 _swigc__p_wxInitDialogEvent,
55501 _swigc__p_wxInputStream,
55502 _swigc__p_wxInternetFSHandler,
55503 _swigc__p_wxItemContainer,
55504 _swigc__p_wxJPEGHandler,
55505 _swigc__p_wxKeyEvent,
55506 _swigc__p_wxLayoutConstraints,
55507 _swigc__p_wxMaximizeEvent,
55508 _swigc__p_wxMemoryFSHandler,
55509 _swigc__p_wxMenu,
55510 _swigc__p_wxMenuBar,
55511 _swigc__p_wxMenuBarBase,
55512 _swigc__p_wxMenuEvent,
55513 _swigc__p_wxMenuItem,
55514 _swigc__p_wxMouseCaptureChangedEvent,
55515 _swigc__p_wxMouseCaptureLostEvent,
55516 _swigc__p_wxMouseEvent,
55517 _swigc__p_wxMoveEvent,
55518 _swigc__p_wxNavigationKeyEvent,
55519 _swigc__p_wxNcPaintEvent,
55520 _swigc__p_wxNotifyEvent,
55521 _swigc__p_wxObject,
55522 _swigc__p_wxOutputStream,
55523 _swigc__p_wxPCXHandler,
55524 _swigc__p_wxPNGHandler,
55525 _swigc__p_wxPNMHandler,
55526 _swigc__p_wxPaintEvent,
55527 _swigc__p_wxPaletteChangedEvent,
55528 _swigc__p_wxPaperSize,
55529 _swigc__p_wxPoint,
55530 _swigc__p_wxPoint2D,
55531 _swigc__p_wxPropagateOnce,
55532 _swigc__p_wxPropagationDisabler,
55533 _swigc__p_wxPyApp,
55534 _swigc__p_wxPyCommandEvent,
55535 _swigc__p_wxPyDropTarget,
55536 _swigc__p_wxPyEvent,
55537 _swigc__p_wxPyFileSystemHandler,
55538 _swigc__p_wxPyImageHandler,
55539 _swigc__p_wxPyInputStream,
55540 _swigc__p_wxPySizer,
55541 _swigc__p_wxPyValidator,
55542 _swigc__p_wxQuantize,
55543 _swigc__p_wxQueryNewPaletteEvent,
55544 _swigc__p_wxRealPoint,
55545 _swigc__p_wxRect,
55546 _swigc__p_wxRegion,
55547 _swigc__p_wxScrollEvent,
55548 _swigc__p_wxScrollWinEvent,
55549 _swigc__p_wxSetCursorEvent,
55550 _swigc__p_wxShowEvent,
55551 _swigc__p_wxSize,
55552 _swigc__p_wxSizeEvent,
55553 _swigc__p_wxSizer,
55554 _swigc__p_wxSizerItem,
55555 _swigc__p_wxStaticBox,
55556 _swigc__p_wxStaticBoxSizer,
55557 _swigc__p_wxStdDialogButtonSizer,
55558 _swigc__p_wxSysColourChangedEvent,
55559 _swigc__p_wxTIFFHandler,
55560 _swigc__p_wxToolTip,
55561 _swigc__p_wxUpdateUIEvent,
55562 _swigc__p_wxValidator,
55563 _swigc__p_wxVisualAttributes,
55564 _swigc__p_wxWindow,
55565 _swigc__p_wxWindowCreateEvent,
55566 _swigc__p_wxWindowDestroyEvent,
55567 _swigc__p_wxXPMHandler,
55568 _swigc__p_wxZipFSHandler,
55569 };
55570
55571
55572 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
55573
55574 static swig_const_info swig_const_table[] = {
55575 {0, 0, 0, 0.0, 0, 0}};
55576
55577 #ifdef __cplusplus
55578 }
55579 #endif
55580 /* -----------------------------------------------------------------------------
55581 * Type initialization:
55582 * This problem is tough by the requirement that no dynamic
55583 * memory is used. Also, since swig_type_info structures store pointers to
55584 * swig_cast_info structures and swig_cast_info structures store pointers back
55585 * to swig_type_info structures, we need some lookup code at initialization.
55586 * The idea is that swig generates all the structures that are needed.
55587 * The runtime then collects these partially filled structures.
55588 * The SWIG_InitializeModule function takes these initial arrays out of
55589 * swig_module, and does all the lookup, filling in the swig_module.types
55590 * array with the correct data and linking the correct swig_cast_info
55591 * structures together.
55592 *
55593 * The generated swig_type_info structures are assigned staticly to an initial
55594 * array. We just loop though that array, and handle each type individually.
55595 * First we lookup if this type has been already loaded, and if so, use the
55596 * loaded structure instead of the generated one. Then we have to fill in the
55597 * cast linked list. The cast data is initially stored in something like a
55598 * two-dimensional array. Each row corresponds to a type (there are the same
55599 * number of rows as there are in the swig_type_initial array). Each entry in
55600 * a column is one of the swig_cast_info structures for that type.
55601 * The cast_initial array is actually an array of arrays, because each row has
55602 * a variable number of columns. So to actually build the cast linked list,
55603 * we find the array of casts associated with the type, and loop through it
55604 * adding the casts to the list. The one last trick we need to do is making
55605 * sure the type pointer in the swig_cast_info struct is correct.
55606 *
55607 * First off, we lookup the cast->type name to see if it is already loaded.
55608 * There are three cases to handle:
55609 * 1) If the cast->type has already been loaded AND the type we are adding
55610 * casting info to has not been loaded (it is in this module), THEN we
55611 * replace the cast->type pointer with the type pointer that has already
55612 * been loaded.
55613 * 2) If BOTH types (the one we are adding casting info to, and the
55614 * cast->type) are loaded, THEN the cast info has already been loaded by
55615 * the previous module so we just ignore it.
55616 * 3) Finally, if cast->type has not already been loaded, then we add that
55617 * swig_cast_info to the linked list (because the cast->type) pointer will
55618 * be correct.
55619 * ----------------------------------------------------------------------------- */
55620
55621 #ifdef __cplusplus
55622 extern "C" {
55623 #if 0
55624 } /* c-mode */
55625 #endif
55626 #endif
55627
55628 #if 0
55629 #define SWIGRUNTIME_DEBUG
55630 #endif
55631
55632 SWIGRUNTIME void
55633 SWIG_InitializeModule(void *clientdata) {
55634 size_t i;
55635 swig_module_info *module_head;
55636 static int init_run = 0;
55637
55638 clientdata = clientdata;
55639
55640 if (init_run) return;
55641 init_run = 1;
55642
55643 /* Initialize the swig_module */
55644 swig_module.type_initial = swig_type_initial;
55645 swig_module.cast_initial = swig_cast_initial;
55646
55647 /* Try and load any already created modules */
55648 module_head = SWIG_GetModule(clientdata);
55649 if (module_head) {
55650 swig_module.next = module_head->next;
55651 module_head->next = &swig_module;
55652 } else {
55653 /* This is the first module loaded */
55654 swig_module.next = &swig_module;
55655 SWIG_SetModule(clientdata, &swig_module);
55656 }
55657
55658 /* Now work on filling in swig_module.types */
55659 #ifdef SWIGRUNTIME_DEBUG
55660 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
55661 #endif
55662 for (i = 0; i < swig_module.size; ++i) {
55663 swig_type_info *type = 0;
55664 swig_type_info *ret;
55665 swig_cast_info *cast;
55666
55667 #ifdef SWIGRUNTIME_DEBUG
55668 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55669 #endif
55670
55671 /* if there is another module already loaded */
55672 if (swig_module.next != &swig_module) {
55673 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
55674 }
55675 if (type) {
55676 /* Overwrite clientdata field */
55677 #ifdef SWIGRUNTIME_DEBUG
55678 printf("SWIG_InitializeModule: found type %s\n", type->name);
55679 #endif
55680 if (swig_module.type_initial[i]->clientdata) {
55681 type->clientdata = swig_module.type_initial[i]->clientdata;
55682 #ifdef SWIGRUNTIME_DEBUG
55683 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
55684 #endif
55685 }
55686 } else {
55687 type = swig_module.type_initial[i];
55688 }
55689
55690 /* Insert casting types */
55691 cast = swig_module.cast_initial[i];
55692 while (cast->type) {
55693 /* Don't need to add information already in the list */
55694 ret = 0;
55695 #ifdef SWIGRUNTIME_DEBUG
55696 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
55697 #endif
55698 if (swig_module.next != &swig_module) {
55699 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
55700 #ifdef SWIGRUNTIME_DEBUG
55701 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
55702 #endif
55703 }
55704 if (ret) {
55705 if (type == swig_module.type_initial[i]) {
55706 #ifdef SWIGRUNTIME_DEBUG
55707 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
55708 #endif
55709 cast->type = ret;
55710 ret = 0;
55711 } else {
55712 /* Check for casting already in the list */
55713 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
55714 #ifdef SWIGRUNTIME_DEBUG
55715 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
55716 #endif
55717 if (!ocast) ret = 0;
55718 }
55719 }
55720
55721 if (!ret) {
55722 #ifdef SWIGRUNTIME_DEBUG
55723 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
55724 #endif
55725 if (type->cast) {
55726 type->cast->prev = cast;
55727 cast->next = type->cast;
55728 }
55729 type->cast = cast;
55730 }
55731 cast++;
55732 }
55733 /* Set entry in modules->types array equal to the type */
55734 swig_module.types[i] = type;
55735 }
55736 swig_module.types[i] = 0;
55737
55738 #ifdef SWIGRUNTIME_DEBUG
55739 printf("**** SWIG_InitializeModule: Cast List ******\n");
55740 for (i = 0; i < swig_module.size; ++i) {
55741 int j = 0;
55742 swig_cast_info *cast = swig_module.cast_initial[i];
55743 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55744 while (cast->type) {
55745 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
55746 cast++;
55747 ++j;
55748 }
55749 printf("---- Total casts: %d\n",j);
55750 }
55751 printf("**** SWIG_InitializeModule: Cast List ******\n");
55752 #endif
55753 }
55754
55755 /* This function will propagate the clientdata field of type to
55756 * any new swig_type_info structures that have been added into the list
55757 * of equivalent types. It is like calling
55758 * SWIG_TypeClientData(type, clientdata) a second time.
55759 */
55760 SWIGRUNTIME void
55761 SWIG_PropagateClientData(void) {
55762 size_t i;
55763 swig_cast_info *equiv;
55764 static int init_run = 0;
55765
55766 if (init_run) return;
55767 init_run = 1;
55768
55769 for (i = 0; i < swig_module.size; i++) {
55770 if (swig_module.types[i]->clientdata) {
55771 equiv = swig_module.types[i]->cast;
55772 while (equiv) {
55773 if (!equiv->converter) {
55774 if (equiv->type && !equiv->type->clientdata)
55775 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
55776 }
55777 equiv = equiv->next;
55778 }
55779 }
55780 }
55781 }
55782
55783 #ifdef __cplusplus
55784 #if 0
55785 {
55786 /* c-mode */
55787 #endif
55788 }
55789 #endif
55790
55791
55792
55793 #ifdef __cplusplus
55794 extern "C" {
55795 #endif
55796
55797 /* Python-specific SWIG API */
55798 #define SWIG_newvarlink() SWIG_Python_newvarlink()
55799 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
55800 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
55801
55802 /* -----------------------------------------------------------------------------
55803 * global variable support code.
55804 * ----------------------------------------------------------------------------- */
55805
55806 typedef struct swig_globalvar {
55807 char *name; /* Name of global variable */
55808 PyObject *(*get_attr)(void); /* Return the current value */
55809 int (*set_attr)(PyObject *); /* Set the value */
55810 struct swig_globalvar *next;
55811 } swig_globalvar;
55812
55813 typedef struct swig_varlinkobject {
55814 PyObject_HEAD
55815 swig_globalvar *vars;
55816 } swig_varlinkobject;
55817
55818 SWIGINTERN PyObject *
55819 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
55820 return PyString_FromString("<Swig global variables>");
55821 }
55822
55823 SWIGINTERN PyObject *
55824 swig_varlink_str(swig_varlinkobject *v) {
55825 PyObject *str = PyString_FromString("(");
55826 swig_globalvar *var;
55827 for (var = v->vars; var; var=var->next) {
55828 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
55829 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
55830 }
55831 PyString_ConcatAndDel(&str,PyString_FromString(")"));
55832 return str;
55833 }
55834
55835 SWIGINTERN int
55836 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
55837 PyObject *str = swig_varlink_str(v);
55838 fprintf(fp,"Swig global variables ");
55839 fprintf(fp,"%s\n", PyString_AsString(str));
55840 Py_DECREF(str);
55841 return 0;
55842 }
55843
55844 SWIGINTERN void
55845 swig_varlink_dealloc(swig_varlinkobject *v) {
55846 swig_globalvar *var = v->vars;
55847 while (var) {
55848 swig_globalvar *n = var->next;
55849 free(var->name);
55850 free(var);
55851 var = n;
55852 }
55853 }
55854
55855 SWIGINTERN PyObject *
55856 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
55857 PyObject *res = NULL;
55858 swig_globalvar *var = v->vars;
55859 while (var) {
55860 if (strcmp(var->name,n) == 0) {
55861 res = (*var->get_attr)();
55862 break;
55863 }
55864 var = var->next;
55865 }
55866 if (res == NULL && !PyErr_Occurred()) {
55867 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55868 }
55869 return res;
55870 }
55871
55872 SWIGINTERN int
55873 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
55874 int res = 1;
55875 swig_globalvar *var = v->vars;
55876 while (var) {
55877 if (strcmp(var->name,n) == 0) {
55878 res = (*var->set_attr)(p);
55879 break;
55880 }
55881 var = var->next;
55882 }
55883 if (res == 1 && !PyErr_Occurred()) {
55884 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55885 }
55886 return res;
55887 }
55888
55889 SWIGINTERN PyTypeObject*
55890 swig_varlink_type(void) {
55891 static char varlink__doc__[] = "Swig var link object";
55892 static PyTypeObject varlink_type;
55893 static int type_init = 0;
55894 if (!type_init) {
55895 const PyTypeObject tmp
55896 = {
55897 PyObject_HEAD_INIT(NULL)
55898 0, /* Number of items in variable part (ob_size) */
55899 (char *)"swigvarlink", /* Type name (tp_name) */
55900 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
55901 0, /* Itemsize (tp_itemsize) */
55902 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
55903 (printfunc) swig_varlink_print, /* Print (tp_print) */
55904 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
55905 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
55906 0, /* tp_compare */
55907 (reprfunc) swig_varlink_repr, /* tp_repr */
55908 0, /* tp_as_number */
55909 0, /* tp_as_sequence */
55910 0, /* tp_as_mapping */
55911 0, /* tp_hash */
55912 0, /* tp_call */
55913 (reprfunc)swig_varlink_str, /* tp_str */
55914 0, /* tp_getattro */
55915 0, /* tp_setattro */
55916 0, /* tp_as_buffer */
55917 0, /* tp_flags */
55918 varlink__doc__, /* tp_doc */
55919 0, /* tp_traverse */
55920 0, /* tp_clear */
55921 0, /* tp_richcompare */
55922 0, /* tp_weaklistoffset */
55923 #if PY_VERSION_HEX >= 0x02020000
55924 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
55925 #endif
55926 #if PY_VERSION_HEX >= 0x02030000
55927 0, /* tp_del */
55928 #endif
55929 #ifdef COUNT_ALLOCS
55930 0,0,0,0 /* tp_alloc -> tp_next */
55931 #endif
55932 };
55933 varlink_type = tmp;
55934 varlink_type.ob_type = &PyType_Type;
55935 type_init = 1;
55936 }
55937 return &varlink_type;
55938 }
55939
55940 /* Create a variable linking object for use later */
55941 SWIGINTERN PyObject *
55942 SWIG_Python_newvarlink(void) {
55943 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
55944 if (result) {
55945 result->vars = 0;
55946 }
55947 return ((PyObject*) result);
55948 }
55949
55950 SWIGINTERN void
55951 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
55952 swig_varlinkobject *v = (swig_varlinkobject *) p;
55953 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
55954 if (gv) {
55955 size_t size = strlen(name)+1;
55956 gv->name = (char *)malloc(size);
55957 if (gv->name) {
55958 strncpy(gv->name,name,size);
55959 gv->get_attr = get_attr;
55960 gv->set_attr = set_attr;
55961 gv->next = v->vars;
55962 }
55963 }
55964 v->vars = gv;
55965 }
55966
55967 SWIGINTERN PyObject *
55968 SWIG_globals() {
55969 static PyObject *_SWIG_globals = 0;
55970 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
55971 return _SWIG_globals;
55972 }
55973
55974 /* -----------------------------------------------------------------------------
55975 * constants/methods manipulation
55976 * ----------------------------------------------------------------------------- */
55977
55978 /* Install Constants */
55979 SWIGINTERN void
55980 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
55981 PyObject *obj = 0;
55982 size_t i;
55983 for (i = 0; constants[i].type; ++i) {
55984 switch(constants[i].type) {
55985 case SWIG_PY_POINTER:
55986 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
55987 break;
55988 case SWIG_PY_BINARY:
55989 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
55990 break;
55991 default:
55992 obj = 0;
55993 break;
55994 }
55995 if (obj) {
55996 PyDict_SetItemString(d, constants[i].name, obj);
55997 Py_DECREF(obj);
55998 }
55999 }
56000 }
56001
56002 /* -----------------------------------------------------------------------------*/
56003 /* Fix SwigMethods to carry the callback ptrs when needed */
56004 /* -----------------------------------------------------------------------------*/
56005
56006 SWIGINTERN void
56007 SWIG_Python_FixMethods(PyMethodDef *methods,
56008 swig_const_info *const_table,
56009 swig_type_info **types,
56010 swig_type_info **types_initial) {
56011 size_t i;
56012 for (i = 0; methods[i].ml_name; ++i) {
56013 const char *c = methods[i].ml_doc;
56014 if (c && (c = strstr(c, "swig_ptr: "))) {
56015 int j;
56016 swig_const_info *ci = 0;
56017 const char *name = c + 10;
56018 for (j = 0; const_table[j].type; ++j) {
56019 if (strncmp(const_table[j].name, name,
56020 strlen(const_table[j].name)) == 0) {
56021 ci = &(const_table[j]);
56022 break;
56023 }
56024 }
56025 if (ci) {
56026 size_t shift = (ci->ptype) - types;
56027 swig_type_info *ty = types_initial[shift];
56028 size_t ldoc = (c - methods[i].ml_doc);
56029 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
56030 char *ndoc = (char*)malloc(ldoc + lptr + 10);
56031 if (ndoc) {
56032 char *buff = ndoc;
56033 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
56034 if (ptr) {
56035 strncpy(buff, methods[i].ml_doc, ldoc);
56036 buff += ldoc;
56037 strncpy(buff, "swig_ptr: ", 10);
56038 buff += 10;
56039 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
56040 methods[i].ml_doc = ndoc;
56041 }
56042 }
56043 }
56044 }
56045 }
56046 }
56047
56048 #ifdef __cplusplus
56049 }
56050 #endif
56051
56052 /* -----------------------------------------------------------------------------*
56053 * Partial Init method
56054 * -----------------------------------------------------------------------------*/
56055
56056 #ifdef __cplusplus
56057 extern "C"
56058 #endif
56059 SWIGEXPORT void SWIG_init(void) {
56060 PyObject *m, *d;
56061
56062 /* Fix SwigMethods to carry the callback ptrs when needed */
56063 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
56064
56065 m = Py_InitModule((char *) SWIG_name, SwigMethods);
56066 d = PyModule_GetDict(m);
56067
56068 SWIG_InitializeModule(0);
56069 SWIG_InstallConstants(d,swig_const_table);
56070
56071
56072
56073 #ifndef wxPyUSE_EXPORT
56074 // Make our API structure a CObject so other modules can import it
56075 // from this module.
56076 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
56077 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
56078 Py_XDECREF(cobj);
56079 #endif
56080
56081 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
56082 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
56083 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
56084 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
56085 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
56086 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
56087 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
56088 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
56089 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
56090 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
56091 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
56092 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
56093 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
56094 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
56095 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
56096 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
56097 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
56098 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
56099 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
56100 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
56101 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
56102 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
56103 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
56104 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
56105 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
56106 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
56107 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
56108 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
56109 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
56110 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
56111 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
56112 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
56113 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
56114 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
56115 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
56116 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
56117 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
56118 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
56119 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
56120 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
56121 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
56122 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
56123 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
56124 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
56125 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
56126 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
56127 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
56128 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
56129 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
56130 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
56131 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
56132 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
56133 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
56134 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
56135 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
56136 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
56137 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
56138 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
56139 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
56140 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
56141 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
56142 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
56143 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
56144 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
56145 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
56146 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
56147 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
56148 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
56149 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
56150 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
56151 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
56152 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
56153 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
56154 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
56155 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
56156 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
56157 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
56158 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
56159 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
56160 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
56161 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
56162 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
56163 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
56164 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
56165 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
56166 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
56167 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
56168 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
56169 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
56170 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
56171 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
56172 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
56173 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
56174 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
56175 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
56176 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
56177 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
56178 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
56179 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
56180 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
56181 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
56182 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
56183 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
56184 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
56185 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
56186 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
56187 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
56188 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
56189 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
56190 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
56191 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
56192 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
56193 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
56194 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
56195 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
56196 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
56197 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
56198 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
56199 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
56200 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
56201 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
56202 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
56203 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
56204 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
56205 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
56206 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
56207 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
56208 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
56209 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
56210 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
56211 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
56212 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
56213 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
56214 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
56215 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
56216 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
56217 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
56218 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
56219 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
56220 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
56221 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
56222 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
56223 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
56224 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
56225 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
56226 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
56227 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
56228 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
56229 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
56230 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
56231 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
56232 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
56233 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
56234 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
56235 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
56236 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
56237 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
56238 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
56239 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
56240 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
56241 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
56242 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
56243 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
56244 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
56245 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
56246 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
56247 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
56248 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
56249 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
56250 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
56251 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
56252 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
56253 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
56254 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
56255 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
56256 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
56257 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
56258 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
56259 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
56260 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
56261 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
56262 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
56263 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
56264 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
56265 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
56266 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
56267 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
56268 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
56269 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
56270 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
56271 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
56272 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
56273 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
56274 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
56275 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
56276 SWIG_Python_SetConstant(d, "PD_AUTO_HIDE",SWIG_From_int(static_cast< int >(wxPD_AUTO_HIDE)));
56277 SWIG_Python_SetConstant(d, "PD_APP_MODAL",SWIG_From_int(static_cast< int >(wxPD_APP_MODAL)));
56278 SWIG_Python_SetConstant(d, "PD_CAN_ABORT",SWIG_From_int(static_cast< int >(wxPD_CAN_ABORT)));
56279 SWIG_Python_SetConstant(d, "PD_ELAPSED_TIME",SWIG_From_int(static_cast< int >(wxPD_ELAPSED_TIME)));
56280 SWIG_Python_SetConstant(d, "PD_ESTIMATED_TIME",SWIG_From_int(static_cast< int >(wxPD_ESTIMATED_TIME)));
56281 SWIG_Python_SetConstant(d, "PD_REMAINING_TIME",SWIG_From_int(static_cast< int >(wxPD_REMAINING_TIME)));
56282 SWIG_Python_SetConstant(d, "PD_SMOOTH",SWIG_From_int(static_cast< int >(wxPD_SMOOTH)));
56283 SWIG_Python_SetConstant(d, "PD_CAN_SKIP",SWIG_From_int(static_cast< int >(wxPD_CAN_SKIP)));
56284 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
56285 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
56286 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
56287 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
56288 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
56289 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
56290 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
56291 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
56292 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
56293 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
56294 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
56295 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
56296 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
56297 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
56298 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
56299 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
56300 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
56301 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
56302 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
56303 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
56304 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
56305 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
56306 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
56307 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
56308 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
56309 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
56310 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
56311 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
56312 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
56313 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
56314 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
56315 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
56316 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
56317 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
56318 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
56319 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
56320 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
56321 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
56322 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
56323 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
56324 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
56325 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
56326 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
56327 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
56328 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
56329 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
56330 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
56331 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
56332 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
56333 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
56334 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
56335 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
56336 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
56337 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
56338 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
56339 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
56340 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
56341 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
56342 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
56343 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
56344 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
56345 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
56346 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
56347 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
56348 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
56349 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
56350 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
56351 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
56352 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
56353 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
56354 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
56355 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
56356 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
56357 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
56358 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
56359 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
56360 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
56361 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
56362 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
56363 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
56364 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
56365 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
56366 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
56367 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
56368 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
56369 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
56370 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
56371 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
56372 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
56373 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
56374 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
56375 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
56376 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
56377 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
56378 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
56379 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
56380 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
56381 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
56382 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
56383 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
56384 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
56385 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
56386 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
56387 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
56388 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
56389 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
56390 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
56391 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
56392 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
56393 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
56394 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
56395 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
56396 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
56397 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
56398 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
56399 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
56400 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
56401 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
56402 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
56403 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
56404 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
56405 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
56406 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
56407 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
56408 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
56409 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
56410 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
56411 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
56412 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
56413 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
56414 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
56415 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
56416 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
56417 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
56418 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
56419 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
56420 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
56421 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
56422 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
56423 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
56424 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
56425 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
56426 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
56427 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
56428 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
56429 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
56430 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
56431 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
56432 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
56433 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
56434 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
56435 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
56436 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
56437 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
56438 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
56439 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
56440 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
56441 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
56442 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
56443 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
56444 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
56445 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
56446 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
56447 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
56448 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
56449 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
56450 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
56451 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
56452 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
56453 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
56454 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
56455 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
56456 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
56457 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
56458 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
56459 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
56460 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
56461 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
56462 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
56463 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
56464 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
56465 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
56466 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
56467 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
56468 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
56469 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
56470 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
56471 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
56472 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
56473 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
56474 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
56475 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
56476 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
56477 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
56478 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
56479 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
56480 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
56481 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
56482 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
56483 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
56484 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
56485 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
56486 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
56487 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
56488 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
56489 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
56490 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
56491 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
56492 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
56493 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
56494 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
56495 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
56496 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
56497 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
56498 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
56499 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
56500 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
56501 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
56502 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
56503 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
56504 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
56505 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
56506 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
56507 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
56508 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
56509 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
56510 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
56511 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
56512 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
56513 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
56514 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
56515 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
56516 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
56517 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
56518 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
56519 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
56520 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
56521 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
56522 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
56523 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
56524 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
56525 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
56526 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
56527 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
56528 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
56529 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
56530 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
56531 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
56532 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
56533 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
56534 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
56535 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
56536 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
56537 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
56538 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
56539 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
56540 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
56541 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
56542 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
56543 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
56544 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
56545 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
56546 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
56547 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
56548 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
56549 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
56550 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
56551 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
56552 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
56553 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
56554 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
56555 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
56556 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
56557 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
56558 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
56559 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
56560 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
56561 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
56562 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
56563 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
56564 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
56565 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
56566 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
56567 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
56568 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
56569 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
56570 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
56571 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
56572 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
56573 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
56574 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
56575 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
56576 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
56577 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
56578 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
56579 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
56580 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
56581 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
56582 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
56583 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
56584 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
56585 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
56586 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
56587 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
56588 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
56589 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
56590 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
56591 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
56592 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
56593 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
56594 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
56595 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
56596 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
56597 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
56598 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
56599 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
56600 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
56601 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
56602 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
56603 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
56604 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
56605 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
56606 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
56607 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
56608 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
56609 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
56610 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
56611 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
56612 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
56613 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
56614 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
56615 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
56616 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
56617 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
56618 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
56619 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
56620 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
56621 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
56622 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
56623 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
56624 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
56625 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
56626 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
56627 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
56628 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
56629 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
56630 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
56631 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
56632 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
56633 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
56634 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
56635 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
56636 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
56637 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
56638 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
56639 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
56640 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
56641 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
56642 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
56643 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
56644 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
56645 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
56646 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
56647 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
56648 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
56649 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
56650 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
56651 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
56652 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
56653 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
56654 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
56655 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
56656 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
56657 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
56658 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
56659 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
56660 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
56661 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
56662 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
56663 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
56664 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
56665 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
56666 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
56667 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
56668 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
56669 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
56670 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
56671 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
56672 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
56673 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
56674 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
56675 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
56676 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
56677 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
56678 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
56679 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
56680 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
56681 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
56682 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
56683 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
56684 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
56685 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
56686 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
56687 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
56688 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
56689 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
56690 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
56691 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
56692 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
56693 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
56694 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
56695 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
56696 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
56697 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
56698 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
56699 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
56700 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
56701 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
56702 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
56703 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
56704 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
56705 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
56706 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
56707 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
56708 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
56709 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
56710 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
56711 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
56712 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
56713 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
56714 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
56715 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
56716 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
56717 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
56718 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
56719 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
56720 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
56721 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
56722 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
56723 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
56724 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
56725 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
56726 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
56727 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
56728 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
56729 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
56730 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
56731 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
56732 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
56733 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
56734 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
56735 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
56736 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
56737 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
56738 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
56739 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
56740 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
56741 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
56742 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
56743
56744 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
56745
56746
56747 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
56748
56749 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
56750 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
56751 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
56752 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
56753 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
56754 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
56755 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
56756 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
56757 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
56758 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
56759 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
56760 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
56761 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
56762 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
56763 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
56764 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
56765 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
56766 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
56767 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
56768 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
56769 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
56770 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
56771 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
56772 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
56773 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
56774 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
56775 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
56776 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
56777 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
56778 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
56779 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
56780 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
56781 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
56782 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
56783 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
56784 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
56785 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
56786 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
56787 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
56788 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
56789 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
56790 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
56791 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
56792 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
56793 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
56794 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
56795 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
56796 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
56797 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
56798 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
56799 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
56800 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
56801 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
56802 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
56803 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
56804 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
56805 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
56806 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
56807 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
56808 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
56809 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
56810 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
56811 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
56812 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
56813 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
56814 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
56815 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
56816 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
56817 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
56818 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
56819 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
56820 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
56821 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
56822 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
56823 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
56824 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
56825 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
56826 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
56827 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
56828 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
56829 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
56830 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
56831 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
56832 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
56833 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
56834 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
56835 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
56836 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
56837 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
56838 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
56839 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
56840 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
56841 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
56842 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
56843 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
56844 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
56845 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
56846 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
56847 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
56848 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
56849 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
56850 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
56851 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
56852 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
56853 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
56854 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
56855 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
56856 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
56857 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
56858 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
56859 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
56860 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
56861 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
56862 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
56863 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
56864 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
56865 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
56866 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
56867 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
56868 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
56869 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
56870 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
56871 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
56872 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
56873 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
56874 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
56875 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
56876 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
56877 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
56878 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
56879 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
56880 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
56881 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
56882 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
56883 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
56884 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
56885 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
56886 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
56887 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
56888 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
56889 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
56890 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
56891 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
56892 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
56893 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
56894 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
56895 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
56896 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
56897 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
56898 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
56899 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
56900 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
56901 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
56902 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
56903 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
56904 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
56905 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
56906 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
56907 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
56908 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
56909 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
56910 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
56911 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
56912 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
56913 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
56914 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
56915 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
56916 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
56917 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
56918 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
56919 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
56920 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
56921 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
56922 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
56923 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
56924 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
56925 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
56926 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
56927 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
56928 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
56929 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
56930 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
56931 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
56932 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
56933 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
56934 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
56935 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
56936 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
56937 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
56938 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
56939 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
56940 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
56941 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
56942 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
56943 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
56944 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
56945 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
56946 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
56947 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
56948 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
56949 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
56950 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
56951 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
56952 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
56953 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
56954 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
56955 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
56956 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
56957 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
56958 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
56959 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
56960 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
56961
56962 // Initialize threading, some globals and such
56963 __wxPyPreStart(d);
56964
56965
56966 // Although these are defined in __version__ they need to be here too so
56967 // that an assert can be done to ensure that the wxPython and the wxWindows
56968 // versions match.
56969 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
56970 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
56971 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
56972
56973 }
56974
wxWidgets (Impactor)